import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String artefactId = artefactId_example; // String | the ID of the annotation
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteAnnotation(dbName, artefactId, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#deleteAnnotation");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String artefactId = artefactId_example; // String | the ID of the annotation
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteAnnotation(dbName, artefactId, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#deleteAnnotation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *artefactId = artefactId_example; // the ID of the annotation (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteAnnotationWith:dbName
    artefactId:artefactId
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var artefactId = artefactId_example; // {String} the ID of the annotation
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var artefactId = artefactId_example;  // String | the ID of the annotation (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteAnnotation(dbName, artefactId, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.deleteAnnotation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$artefactId = artefactId_example; // String | the ID of the annotation
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteAnnotation($dbName, $artefactId, $key);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->deleteAnnotation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $artefactId = artefactId_example; # String | the ID of the annotation
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteAnnotation(dbName => $dbName, artefactId => $artefactId, key => $key);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->deleteAnnotation: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
artefactId = artefactId_example # String | the ID of the annotation (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_annotation(dbName, artefactId, key)
except ApiException as e:
    print("Exception when calling AnnotationsApi->deleteAnnotation: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let artefactId = artefactId_example; // String
    let key = key_example; // String

    let mut context = AnnotationsApi::Context::default();
    let result = client.deleteAnnotation(dbName, artefactId, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
        String access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data

        try {
            apiInstance.deleteAnnotations(dbName, key, path, access);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#deleteAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
        String access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data

        try {
            apiInstance.deleteAnnotations(dbName, key, path, access);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#deleteAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
String *path = path_example; // the url-coded path in the pkm the retrieved annotations are about (optional) (default to null)
String *access = access_example; // json path allowing to retrieve the text to analyze in the retrieved data (optional) (default to null)

[apiInstance deleteAnnotationsWith:dbName
    key:key
    path:path
    access:access
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var opts = {
  'path': path_example, // {String} the url-coded path in the pkm the retrieved annotations are about
  'access': access_example // {String} json path allowing to retrieve the text to analyze in the retrieved data
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var path = path_example;  // String | the url-coded path in the pkm the retrieved annotations are about (optional)  (default to null)
            var access = access_example;  // String | json path allowing to retrieve the text to analyze in the retrieved data (optional)  (default to null)

            try {
                apiInstance.deleteAnnotations(dbName, key, path, access);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.deleteAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
$access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data

try {
    $api_instance->deleteAnnotations($dbName, $key, $path, $access);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->deleteAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $path = path_example; # String | the url-coded path in the pkm the retrieved annotations are about
my $access = access_example; # String | json path allowing to retrieve the text to analyze in the retrieved data

eval {
    $api_instance->deleteAnnotations(dbName => $dbName, key => $key, path => $path, access => $access);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->deleteAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
path = path_example # String | the url-coded path in the pkm the retrieved annotations are about (optional) (default to null)
access = access_example # String | json path allowing to retrieve the text to analyze in the retrieved data (optional) (default to null)

try:
    api_instance.delete_annotations(dbName, key, path=path, access=access)
except ApiException as e:
    print("Exception when calling AnnotationsApi->deleteAnnotations: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let path = path_example; // String
    let access = access_example; // String

    let mut context = AnnotationsApi::Context::default();
    let result = client.deleteAnnotations(dbName, key, path, access, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String artefactId = artefactId_example; // String | the ID of the annotation
        String key = key_example; // String | Access key to the PKM

        try {
            PkmAnnotations result = apiInstance.getAnnotation(dbName, artefactId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#getAnnotation");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String artefactId = artefactId_example; // String | the ID of the annotation
        String key = key_example; // String | Access key to the PKM

        try {
            PkmAnnotations result = apiInstance.getAnnotation(dbName, artefactId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#getAnnotation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *artefactId = artefactId_example; // the ID of the annotation (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance getAnnotationWith:dbName
    artefactId:artefactId
    key:key
              completionHandler: ^(PkmAnnotations output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var artefactId = artefactId_example; // {String} the ID of the annotation
var key = key_example; // {String} Access key to the PKM

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAnnotation(dbName, artefactId, key, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var artefactId = artefactId_example;  // String | the ID of the annotation (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                PkmAnnotations result = apiInstance.getAnnotation(dbName, artefactId, key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.getAnnotation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$artefactId = artefactId_example; // String | the ID of the annotation
$key = key_example; // String | Access key to the PKM

try {
    $result = $api_instance->getAnnotation($dbName, $artefactId, $key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->getAnnotation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $artefactId = artefactId_example; # String | the ID of the annotation
my $key = key_example; # String | Access key to the PKM

eval {
    my $result = $api_instance->getAnnotation(dbName => $dbName, artefactId => $artefactId, key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->getAnnotation: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
artefactId = artefactId_example # String | the ID of the annotation (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_response = api_instance.get_annotation(dbName, artefactId, key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnnotationsApi->getAnnotation: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let artefactId = artefactId_example; // String
    let key = key_example; // String

    let mut context = AnnotationsApi::Context::default();
    let result = client.getAnnotation(dbName, artefactId, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
        String access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data
        Integer skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
        Integer limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

        try {
            array[PkmAnnotations] result = apiInstance.getAnnotations(dbName, key, path, access, skip, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#getAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
        String access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data
        Integer skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
        Integer limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

        try {
            array[PkmAnnotations] result = apiInstance.getAnnotations(dbName, key, path, access, skip, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#getAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
String *path = path_example; // the url-coded path in the pkm the retrieved annotations are about (optional) (default to null)
String *access = access_example; // json path allowing to retrieve the text to analyze in the retrieved data (optional) (default to null)
Integer *skip = 56; // number of elements to skip, useful for lowering response footprint (optional) (default to 0)
Integer *limit = 56; // maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional) (default to 0)

[apiInstance getAnnotationsWith:dbName
    key:key
    path:path
    access:access
    skip:skip
    limit:limit
              completionHandler: ^(array[PkmAnnotations] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var opts = {
  'path': path_example, // {String} the url-coded path in the pkm the retrieved annotations are about
  'access': access_example, // {String} json path allowing to retrieve the text to analyze in the retrieved data
  'skip': 56, // {Integer} number of elements to skip, useful for lowering response footprint
  'limit': 56 // {Integer} maximum number of elements in the response (zero means no limit), useful for lowering response footprint
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAnnotations(dbName, key, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var path = path_example;  // String | the url-coded path in the pkm the retrieved annotations are about (optional)  (default to null)
            var access = access_example;  // String | json path allowing to retrieve the text to analyze in the retrieved data (optional)  (default to null)
            var skip = 56;  // Integer | number of elements to skip, useful for lowering response footprint (optional)  (default to 0)
            var limit = 56;  // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional)  (default to 0)

            try {
                array[PkmAnnotations] result = apiInstance.getAnnotations(dbName, key, path, access, skip, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.getAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$path = path_example; // String | the url-coded path in the pkm the retrieved annotations are about
$access = access_example; // String | json path allowing to retrieve the text to analyze in the retrieved data
$skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
$limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

try {
    $result = $api_instance->getAnnotations($dbName, $key, $path, $access, $skip, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->getAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $path = path_example; # String | the url-coded path in the pkm the retrieved annotations are about
my $access = access_example; # String | json path allowing to retrieve the text to analyze in the retrieved data
my $skip = 56; # Integer | number of elements to skip, useful for lowering response footprint
my $limit = 56; # Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

eval {
    my $result = $api_instance->getAnnotations(dbName => $dbName, key => $key, path => $path, access => $access, skip => $skip, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->getAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
path = path_example # String | the url-coded path in the pkm the retrieved annotations are about (optional) (default to null)
access = access_example # String | json path allowing to retrieve the text to analyze in the retrieved data (optional) (default to null)
skip = 56 # Integer | number of elements to skip, useful for lowering response footprint (optional) (default to 0)
limit = 56 # Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional) (default to 0)

try:
    api_response = api_instance.get_annotations(dbName, key, path=path, access=access, skip=skip, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnnotationsApi->getAnnotations: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let path = path_example; // String
    let access = access_example; // String
    let skip = 56; // Integer
    let limit = 56; // Integer

    let mut context = AnnotationsApi::Context::default();
    let result = client.getAnnotations(dbName, key, path, access, skip, limit, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmAnnotations] body = ; // array[PkmAnnotations] | 

        try {
            array['String'] result = apiInstance.postAnnotations(dbName, key, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#postAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmAnnotations] body = ; // array[PkmAnnotations] | 

        try {
            array['String'] result = apiInstance.postAnnotations(dbName, key, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#postAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
array[PkmAnnotations] *body = ; // 

[apiInstance postAnnotationsWith:dbName
    key:key
    body:body
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var body = ; // {array[PkmAnnotations]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.postAnnotations(dbName, key, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var body = new array[PkmAnnotations](); // array[PkmAnnotations] | 

            try {
                array['String'] result = apiInstance.postAnnotations(dbName, key, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.postAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$body = ; // array[PkmAnnotations] | 

try {
    $result = $api_instance->postAnnotations($dbName, $key, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->postAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $body = [WWW::OPenAPIClient::Object::array[PkmAnnotations]->new()]; # array[PkmAnnotations] | 

eval {
    my $result = $api_instance->postAnnotations(dbName => $dbName, key => $key, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->postAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
body =  # array[PkmAnnotations] | 

try:
    api_response = api_instance.post_annotations(dbName, key, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnnotationsApi->postAnnotations: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let body = ; // array[PkmAnnotations]

    let mut context = AnnotationsApi::Context::default();
    let result = client.postAnnotations(dbName, key, body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnnotationsApi;

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

public class AnnotationsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmAnnotations] body = ; // array[PkmAnnotations] | 

        try {
            array['String'] result = apiInstance.putAnnotations(dbName, key, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#putAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AnnotationsApi;

public class AnnotationsApiExample {
    public static void main(String[] args) {
        AnnotationsApi apiInstance = new AnnotationsApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmAnnotations] body = ; // array[PkmAnnotations] | 

        try {
            array['String'] result = apiInstance.putAnnotations(dbName, key, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationsApi#putAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationsApi *apiInstance = [[AnnotationsApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
array[PkmAnnotations] *body = ; // 

[apiInstance putAnnotationsWith:dbName
    key:key
    body:body
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.AnnotationsApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var body = ; // {array[PkmAnnotations]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putAnnotations(dbName, key, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AnnotationsApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var body = new array[PkmAnnotations](); // array[PkmAnnotations] | 

            try {
                array['String'] result = apiInstance.putAnnotations(dbName, key, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationsApi.putAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationsApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$body = ; // array[PkmAnnotations] | 

try {
    $result = $api_instance->putAnnotations($dbName, $key, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnnotationsApi->putAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AnnotationsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationsApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $body = [WWW::OPenAPIClient::Object::array[PkmAnnotations]->new()]; # array[PkmAnnotations] | 

eval {
    my $result = $api_instance->putAnnotations(dbName => $dbName, key => $key, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnnotationsApi->putAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AnnotationsApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
body =  # array[PkmAnnotations] | 

try:
    api_response = api_instance.put_annotations(dbName, key, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnnotationsApi->putAnnotations: %s\n" % e)

extern crate AnnotationsApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let body = ; // array[PkmAnnotations]

    let mut context = AnnotationsApi::Context::default();
    let result = client.putAnnotations(dbName, key, body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CVEApi;

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

public class CVEApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String id = id_example; // String | the ID of the CVE document
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCVE(dbName, id, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#deleteCVE");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CVEApi;

public class CVEApiExample {
    public static void main(String[] args) {
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String id = id_example; // String | the ID of the CVE document
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCVE(dbName, id, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#deleteCVE");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CVEApi *apiInstance = [[CVEApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *id = id_example; // the ID of the CVE document (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCVEWith:dbName
    id:id
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CVEApi()
var dbName = dbName_example; // {String} Database name
var id = id_example; // {String} the ID of the CVE document
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CVEApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var id = id_example;  // String | the ID of the CVE document (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCVE(dbName, id, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CVEApi.deleteCVE: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CVEApi();
$dbName = dbName_example; // String | Database name
$id = id_example; // String | the ID of the CVE document
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCVE($dbName, $id, $key);
} catch (Exception $e) {
    echo 'Exception when calling CVEApi->deleteCVE: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CVEApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CVEApi->new();
my $dbName = dbName_example; # String | Database name
my $id = id_example; # String | the ID of the CVE document
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCVE(dbName => $dbName, id => $id, key => $key);
};
if ($@) {
    warn "Exception when calling CVEApi->deleteCVE: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CVEApi()
dbName = dbName_example # String | Database name (default to null)
id = id_example # String | the ID of the CVE document (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cve(dbName, id, key)
except ApiException as e:
    print("Exception when calling CVEApi->deleteCVE: %s\n" % e)

extern crate CVEApi;

pub fn main() {
    let dbName = dbName_example; // String
    let id = id_example; // String
    let key = key_example; // String

    let mut context = CVEApi::Context::default();
    let result = client.deleteCVE(dbName, id, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CVEApi;

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

public class CVEApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCVEs(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#deleteCVEs");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CVEApi;

public class CVEApiExample {
    public static void main(String[] args) {
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCVEs(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#deleteCVEs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CVEApi *apiInstance = [[CVEApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCVEsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CVEApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CVEApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCVEs(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CVEApi.deleteCVEs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CVEApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCVEs($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CVEApi->deleteCVEs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CVEApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CVEApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCVEs(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CVEApi->deleteCVEs: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CVEApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cves(dbName, key)
except ApiException as e:
    print("Exception when calling CVEApi->deleteCVEs: %s\n" % e)

extern crate CVEApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CVEApi::Context::default();
    let result = client.deleteCVEs(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CVEApi;

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

public class CVEApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String id = id_example; // String | CVE document ID
        String state = state_example; // String | CVE state
        String assigner = assigner_example; // String | CVE assigner
        Integer skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
        Integer limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

        try {
            array[PkmCve] result = apiInstance.getCVEs(dbName, key, id, state, assigner, skip, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#getCVEs");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CVEApi;

public class CVEApiExample {
    public static void main(String[] args) {
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        String id = id_example; // String | CVE document ID
        String state = state_example; // String | CVE state
        String assigner = assigner_example; // String | CVE assigner
        Integer skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
        Integer limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

        try {
            array[PkmCve] result = apiInstance.getCVEs(dbName, key, id, state, assigner, skip, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#getCVEs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CVEApi *apiInstance = [[CVEApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
String *id = id_example; // CVE document ID (optional) (default to null)
String *state = state_example; // CVE state (optional) (default to null)
String *assigner = assigner_example; // CVE assigner (optional) (default to null)
Integer *skip = 56; // number of elements to skip, useful for lowering response footprint (optional) (default to 0)
Integer *limit = 56; // maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional) (default to 0)

[apiInstance getCVEsWith:dbName
    key:key
    id:id
    state:state
    assigner:assigner
    skip:skip
    limit:limit
              completionHandler: ^(array[PkmCve] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CVEApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var opts = {
  'id': id_example, // {String} CVE document ID
  'state': state_example, // {String} CVE state
  'assigner': assigner_example, // {String} CVE assigner
  'skip': 56, // {Integer} number of elements to skip, useful for lowering response footprint
  'limit': 56 // {Integer} maximum number of elements in the response (zero means no limit), useful for lowering response footprint
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCVEs(dbName, key, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CVEApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var id = id_example;  // String | CVE document ID (optional)  (default to null)
            var state = state_example;  // String | CVE state (optional)  (default to null)
            var assigner = assigner_example;  // String | CVE assigner (optional)  (default to null)
            var skip = 56;  // Integer | number of elements to skip, useful for lowering response footprint (optional)  (default to 0)
            var limit = 56;  // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional)  (default to 0)

            try {
                array[PkmCve] result = apiInstance.getCVEs(dbName, key, id, state, assigner, skip, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CVEApi.getCVEs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CVEApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$id = id_example; // String | CVE document ID
$state = state_example; // String | CVE state
$assigner = assigner_example; // String | CVE assigner
$skip = 56; // Integer | number of elements to skip, useful for lowering response footprint
$limit = 56; // Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

try {
    $result = $api_instance->getCVEs($dbName, $key, $id, $state, $assigner, $skip, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CVEApi->getCVEs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CVEApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CVEApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $id = id_example; # String | CVE document ID
my $state = state_example; # String | CVE state
my $assigner = assigner_example; # String | CVE assigner
my $skip = 56; # Integer | number of elements to skip, useful for lowering response footprint
my $limit = 56; # Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint

eval {
    my $result = $api_instance->getCVEs(dbName => $dbName, key => $key, id => $id, state => $state, assigner => $assigner, skip => $skip, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CVEApi->getCVEs: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CVEApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
id = id_example # String | CVE document ID (optional) (default to null)
state = state_example # String | CVE state (optional) (default to null)
assigner = assigner_example # String | CVE assigner (optional) (default to null)
skip = 56 # Integer | number of elements to skip, useful for lowering response footprint (optional) (default to 0)
limit = 56 # Integer | maximum number of elements in the response (zero means no limit), useful for lowering response footprint (optional) (default to 0)

try:
    api_response = api_instance.get_cves(dbName, key, id=id, state=state, assigner=assigner, skip=skip, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CVEApi->getCVEs: %s\n" % e)

extern crate CVEApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let id = id_example; // String
    let state = state_example; // String
    let assigner = assigner_example; // String
    let skip = 56; // Integer
    let limit = 56; // Integer

    let mut context = CVEApi::Context::default();
    let result = client.getCVEs(dbName, key, id, state, assigner, skip, limit, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CVEApi;

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

public class CVEApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmCve] body = ; // array[PkmCve] | 

        try {
            apiInstance.postCVEs(dbName, key, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#postCVEs");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CVEApi;

public class CVEApiExample {
    public static void main(String[] args) {
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmCve] body = ; // array[PkmCve] | 

        try {
            apiInstance.postCVEs(dbName, key, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#postCVEs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CVEApi *apiInstance = [[CVEApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
array[PkmCve] *body = ; //  (optional)

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

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CVEApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var opts = {
  'body':  // {array[PkmCve]} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CVEApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var body = new array[PkmCve](); // array[PkmCve] |  (optional) 

            try {
                apiInstance.postCVEs(dbName, key, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling CVEApi.postCVEs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CVEApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$body = ; // array[PkmCve] | 

try {
    $api_instance->postCVEs($dbName, $key, $body);
} catch (Exception $e) {
    echo 'Exception when calling CVEApi->postCVEs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CVEApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CVEApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $body = [WWW::OPenAPIClient::Object::array[PkmCve]->new()]; # array[PkmCve] | 

eval {
    $api_instance->postCVEs(dbName => $dbName, key => $key, body => $body);
};
if ($@) {
    warn "Exception when calling CVEApi->postCVEs: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CVEApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
body =  # array[PkmCve] |  (optional)

try:
    api_instance.post_cves(dbName, key, body=body)
except ApiException as e:
    print("Exception when calling CVEApi->postCVEs: %s\n" % e)

extern crate CVEApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let body = ; // array[PkmCve]

    let mut context = CVEApi::Context::default();
    let result = client.postCVEs(dbName, key, body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CVEApi;

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

public class CVEApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmCve] body = ; // array[PkmCve] | 

        try {
            apiInstance.putCVEs(dbName, key, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#putCVEs");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CVEApi;

public class CVEApiExample {
    public static void main(String[] args) {
        CVEApi apiInstance = new CVEApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM
        array[PkmCve] body = ; // array[PkmCve] | 

        try {
            apiInstance.putCVEs(dbName, key, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CVEApi#putCVEs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CVEApi *apiInstance = [[CVEApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)
array[PkmCve] *body = ; //  (optional)

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

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CVEApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM
var opts = {
  'body':  // {array[PkmCve]} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CVEApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)
            var body = new array[PkmCve](); // array[PkmCve] |  (optional) 

            try {
                apiInstance.putCVEs(dbName, key, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling CVEApi.putCVEs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CVEApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM
$body = ; // array[PkmCve] | 

try {
    $api_instance->putCVEs($dbName, $key, $body);
} catch (Exception $e) {
    echo 'Exception when calling CVEApi->putCVEs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CVEApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CVEApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM
my $body = [WWW::OPenAPIClient::Object::array[PkmCve]->new()]; # array[PkmCve] | 

eval {
    $api_instance->putCVEs(dbName => $dbName, key => $key, body => $body);
};
if ($@) {
    warn "Exception when calling CVEApi->putCVEs: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CVEApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)
body =  # array[PkmCve] |  (optional)

try:
    api_instance.put_cves(dbName, key, body=body)
except ApiException as e:
    print("Exception when calling CVEApi->putCVEs: %s\n" % e)

extern crate CVEApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String
    let body = ; // array[PkmCve]

    let mut context = CVEApi::Context::default();
    let result = client.putCVEs(dbName, key, body, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCAnnotationsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCAnnotations(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCAnnotations($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCAnnotations(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_annotations(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCAnnotations: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCAnnotations(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCAnnotationsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCAnnotationsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCAnnotationsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCAnnotationsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCAnnotationsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCAnnotationsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCAnnotationsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_annotations_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCAnnotationsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCAnnotationsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCComments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCComments");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCCommentsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCComments(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCComments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCComments($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCComments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCComments(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCComments: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_comments(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCComments: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCComments(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCCommentsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCCommentsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCCommentsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCCommentsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCCommentsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCCommentsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCCommentsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_comments_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCCommentsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCCommentsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPAnnotationsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPAnnotations(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPAnnotations($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPAnnotations(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_annotations(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPAnnotations: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPAnnotations(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C++ Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPAnnotationsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C++ Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C++ Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPAnnotationsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPAnnotationsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C++ Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPAnnotationsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPAnnotationsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C++ Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPAnnotationsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPAnnotationsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C++ Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_annotations_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPAnnotationsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPAnnotationsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPComments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPComments");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPCommentsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPComments(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPComments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPComments($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPComments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPComments(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPComments: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_comments(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPComments: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPComments(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C++ Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPCommentsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C++ Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C++ Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPCommentsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPCommentsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C++ Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPCommentsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPCommentsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C++ Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPCommentsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPCommentsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C++ Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_comments_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPCommentsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPCommentsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPSourceCodes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPSourceCodes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPSourceCodesWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPSourceCodes(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPSourceCodes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPSourceCodes($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPSourceCodes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPSourceCodes(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPSourceCodes: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_source_codes(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPSourceCodes: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPSourceCodes(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C++ Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCPPSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCPPSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C++ Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCPPSourceCodesBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C++ Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C++ Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCPPSourceCodesBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCPPSourceCodesBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C++ Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCPPSourceCodesBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCPPSourceCodesBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C++ Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCPPSourceCodesBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCPPSourceCodesBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C++ Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_cpp_source_codes_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCPPSourceCodesBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCPPSourceCodesBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCSourceCodes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCSourceCodes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCSourceCodesWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCSourceCodes(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCSourceCodes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCSourceCodes($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCSourceCodes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCSourceCodes(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCSourceCodes: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_source_codes(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCSourceCodes: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCSourceCodes(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | C Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteCSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteCSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // C Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteCSourceCodesBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} C Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | C Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteCSourceCodesBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteCSourceCodesBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | C Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteCSourceCodesBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteCSourceCodesBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | C Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteCSourceCodesBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteCSourceCodesBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | C Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_c_source_codes_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteCSourceCodesBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteCSourceCodesBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaAnnotationsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaAnnotations(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaAnnotations($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaAnnotations(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_annotations(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaAnnotations: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaAnnotations(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // Java Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaAnnotationsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} Java Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | Java Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaAnnotationsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaAnnotationsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | Java Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaAnnotationsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaAnnotationsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | Java Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaAnnotationsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaAnnotationsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | Java Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_annotations_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaAnnotationsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaAnnotationsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaComments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaComments(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaComments");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaCommentsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaComments(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaComments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaComments($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaComments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaComments(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaComments: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_comments(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaComments: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaComments(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaCommentsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaCommentsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // Java Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaCommentsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} Java Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | Java Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaCommentsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaCommentsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | Java Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaCommentsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaCommentsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | Java Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaCommentsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaCommentsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | Java Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_comments_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaCommentsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaCommentsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaSourceCodes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaSourceCodes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaSourceCodesWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaSourceCodes(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaSourceCodes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaSourceCodes($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaSourceCodes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaSourceCodes(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaSourceCodes: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_source_codes(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaSourceCodes: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaSourceCodes(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Java Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteJavaSourceCodesBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteJavaSourceCodesBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // Java Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteJavaSourceCodesBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} Java Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | Java Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteJavaSourceCodesBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteJavaSourceCodesBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | Java Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteJavaSourceCodesBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteJavaSourceCodesBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | Java Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteJavaSourceCodesBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteJavaSourceCodesBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | Java Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_java_source_codes_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteJavaSourceCodesBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteJavaSourceCodesBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteRawSourceCode(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteRawSourceCode");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteRawSourceCode(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteRawSourceCode");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteRawSourceCodeWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteRawSourceCode(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteRawSourceCode: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteRawSourceCode($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteRawSourceCode: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteRawSourceCode(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteRawSourceCode: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_raw_source_code(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteRawSourceCode: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteRawSourceCode(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteRawSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteRawSourceCodes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteRawSourceCodes(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteRawSourceCodes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteRawSourceCodesWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteRawSourceCodes(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteRawSourceCodes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteRawSourceCodes($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteRawSourceCodes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteRawSourceCodes(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteRawSourceCodes: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_raw_source_codes(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteRawSourceCodes: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteRawSourceCodes(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteSourceCodeAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteSourceCodeAnnotations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteSourceCodeAnnotations(dbName, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteSourceCodeAnnotations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteSourceCodeAnnotationsWith:dbName
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteSourceCodeAnnotations(dbName, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteSourceCodeAnnotations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteSourceCodeAnnotations($dbName, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteSourceCodeAnnotations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteSourceCodeAnnotations(dbName => $dbName, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteSourceCodeAnnotations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_source_code_annotations(dbName, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteSourceCodeAnnotations: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteSourceCodeAnnotations(dbName, key, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CodeApi;

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

public class CodeApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteSourceCodeAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteSourceCodeAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CodeApi;

public class CodeApiExample {
    public static void main(String[] args) {
        CodeApi apiInstance = new CodeApi();
        String dbName = dbName_example; // String | Database name
        String filename = filename_example; // String | Source code filename
        String key = key_example; // String | Access key to the PKM

        try {
            apiInstance.deleteSourceCodeAnnotationsBySourceCodeFilename(dbName, filename, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CodeApi#deleteSourceCodeAnnotationsBySourceCodeFilename");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CodeApi *apiInstance = [[CodeApi alloc] init];
String *dbName = dbName_example; // Database name (default to null)
String *filename = filename_example; // Source code filename (default to null)
String *key = key_example; // Access key to the PKM (default to null)

[apiInstance deleteSourceCodeAnnotationsBySourceCodeFilenameWith:dbName
    filename:filename
    key:key
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PkmRestfulApi = require('pkm_restful_api');

// Create an instance of the API class
var api = new PkmRestfulApi.CodeApi()
var dbName = dbName_example; // {String} Database name
var filename = filename_example; // {String} Source code filename
var key = key_example; // {String} Access key to the PKM

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CodeApi();
            var dbName = dbName_example;  // String | Database name (default to null)
            var filename = filename_example;  // String | Source code filename (default to null)
            var key = key_example;  // String | Access key to the PKM (default to null)

            try {
                apiInstance.deleteSourceCodeAnnotationsBySourceCodeFilename(dbName, filename, key);
            } catch (Exception e) {
                Debug.Print("Exception when calling CodeApi.deleteSourceCodeAnnotationsBySourceCodeFilename: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CodeApi();
$dbName = dbName_example; // String | Database name
$filename = filename_example; // String | Source code filename
$key = key_example; // String | Access key to the PKM

try {
    $api_instance->deleteSourceCodeAnnotationsBySourceCodeFilename($dbName, $filename, $key);
} catch (Exception $e) {
    echo 'Exception when calling CodeApi->deleteSourceCodeAnnotationsBySourceCodeFilename: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CodeApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CodeApi->new();
my $dbName = dbName_example; # String | Database name
my $filename = filename_example; # String | Source code filename
my $key = key_example; # String | Access key to the PKM

eval {
    $api_instance->deleteSourceCodeAnnotationsBySourceCodeFilename(dbName => $dbName, filename => $filename, key => $key);
};
if ($@) {
    warn "Exception when calling CodeApi->deleteSourceCodeAnnotationsBySourceCodeFilename: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CodeApi()
dbName = dbName_example # String | Database name (default to null)
filename = filename_example # String | Source code filename (default to null)
key = key_example # String | Access key to the PKM (default to null)

try:
    api_instance.delete_source_code_annotations_by_source_code_filename(dbName, filename, key)
except ApiException as e:
    print("Exception when calling CodeApi->deleteSourceCodeAnnotationsBySourceCodeFilename: %s\n" % e)

extern crate CodeApi;

pub fn main() {
    let dbName = dbName_example; // String
    let filename = filename_example; // String
    let key = key_example; // String

    let mut context = CodeApi::Context::default();
    let result = client.deleteSourceCodeAnnotationsBySourceCodeFilename(dbName, filename, key, &context).wait();

    println!("{:?}", result);
}