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

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

public class AnalyticsApiExample {

    public static void main(String[] args) {
        
        AnalyticsApi apiInstance = new AnalyticsApi();
        try {
            array[ANALYTICS] result = apiInstance.aNALYTICSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#aNALYTICSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

    public static void main(String[] args) {
        AnalyticsApi apiInstance = new AnalyticsApi();
        try {
            array[ANALYTICS] result = apiInstance.aNALYTICSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#aNALYTICSGet");
            e.printStackTrace();
        }
    }
}

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

// Get all analytics captured
[apiInstance aNALYTICSGetWithCompletionHandler: 
              ^(array[ANALYTICS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.AnalyticsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aNALYTICSGet(callback);

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

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

            var apiInstance = new AnalyticsApi();

            try
            {
                // Get all analytics captured
                array[ANALYTICS] result = apiInstance.aNALYTICSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.aNALYTICSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();

try {
    $result = $api_instance->aNALYTICSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnalyticsApi->aNALYTICSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AnalyticsApi->new();

eval { 
    my $result = $api_instance->aNALYTICSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->aNALYTICSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AnalyticsApi()

try: 
    # Get all analytics captured
    api_response = api_instance.a_nalytics_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalyticsApi->aNALYTICSGet: %s\n" % e)

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

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

public class AnalyticsApiExample {

    public static void main(String[] args) {
        
        AnalyticsApi apiInstance = new AnalyticsApi();
        Integer id = 56; // Integer | 
        try {
            ANALYTICS result = apiInstance.aNALYTICSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#aNALYTICSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

    public static void main(String[] args) {
        AnalyticsApi apiInstance = new AnalyticsApi();
        Integer id = 56; // Integer | 
        try {
            ANALYTICS result = apiInstance.aNALYTICSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalyticsApi#aNALYTICSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Find a specific metric
[apiInstance aNALYTICSIdGetWith:id
              completionHandler: ^(ANALYTICS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.AnalyticsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new AnalyticsApi();
            var id = 56;  // Integer | 

            try
            {
                // Find a specific metric
                ANALYTICS result = apiInstance.aNALYTICSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.aNALYTICSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->aNALYTICSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AnalyticsApi->aNALYTICSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AnalyticsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->aNALYTICSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->aNALYTICSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.AnalyticsApi()
id = 56 # Integer | 

try: 
    # Find a specific metric
    api_response = api_instance.a_nalyticsid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalyticsApi->aNALYTICSIdGet: %s\n" % e)

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

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

public class AnalyticsApiExample {

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

import io.swagger.client.api.AnalyticsApi;

public class AnalyticsApiExample {

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

ANALYTICS *body = ; //  (optional)

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

// Add new analytic metric to database
[apiInstance aNALYTICSPostWith:body
              completionHandler: ^(ANALYTICS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.AnalyticsApi()
var opts = { 
  'body':  // {{ANALYTICS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aNALYTICSPost(opts, callback);

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

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

            var apiInstance = new AnalyticsApi();
            var body = new ANALYTICS(); // ANALYTICS |  (optional) 

            try
            {
                // Add new analytic metric to database
                ANALYTICS result = apiInstance.aNALYTICSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AnalyticsApi.aNALYTICSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAnalyticsApi();
$body = ; // ANALYTICS | 

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

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

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

eval { 
    my $result = $api_instance->aNALYTICSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalyticsApi->aNALYTICSPost: $@\n";
}

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

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

try: 
    # Add new analytic metric to database
    api_response = api_instance.a_nalytics_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalyticsApi->aNALYTICSPost: %s\n" % e)

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

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

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        try {
            array[DOCUMENTS] result = apiInstance.dOCUMENTSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        try {
            array[DOCUMENTS] result = apiInstance.dOCUMENTSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSGet");
            e.printStackTrace();
        }
    }
}

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

// Fetch a list of all documents available
[apiInstance dOCUMENTSGetWithCompletionHandler: 
              ^(array[DOCUMENTS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.DocumentsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dOCUMENTSGet(callback);

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

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

            var apiInstance = new DocumentsApi();

            try
            {
                // Fetch a list of all documents available
                array[DOCUMENTS] result = apiInstance.dOCUMENTSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.dOCUMENTSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDocumentsApi();

try {
    $result = $api_instance->dOCUMENTSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->dOCUMENTSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();

eval { 
    my $result = $api_instance->dOCUMENTSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentsApi->dOCUMENTSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()

try: 
    # Fetch a list of all documents available
    api_response = api_instance.d_ocuments_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentsApi->dOCUMENTSGet: %s\n" % e)

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

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

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove a document from the library
[apiInstance dOCUMENTSIdDeleteWith:id
              completionHandler: ^(DOCUMENTS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.DocumentsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new DocumentsApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove a document from the library
                DOCUMENTS result = apiInstance.dOCUMENTSIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.dOCUMENTSIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDocumentsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->dOCUMENTSIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->dOCUMENTSIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->dOCUMENTSIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentsApi->dOCUMENTSIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
id = 56 # Integer | 

try: 
    # Remove a document from the library
    api_response = api_instance.d_ocumentsid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentsApi->dOCUMENTSIdDelete: %s\n" % e)

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

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

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific document
[apiInstance dOCUMENTSIdGetWith:id
              completionHandler: ^(DOCUMENTS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.DocumentsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new DocumentsApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific document
                DOCUMENTS result = apiInstance.dOCUMENTSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.dOCUMENTSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDocumentsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->dOCUMENTSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->dOCUMENTSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->dOCUMENTSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentsApi->dOCUMENTSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
id = 56 # Integer | 

try: 
    # Search for a specific document
    api_response = api_instance.d_ocumentsid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentsApi->dOCUMENTSIdGet: %s\n" % e)

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

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

public class DocumentsApiExample {

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

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

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

DOCUMENTS *body = ; //  (optional)

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

// upload a new documents Meta data into database
[apiInstance dOCUMENTSPostWith:body
              completionHandler: ^(DOCUMENTS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.DocumentsApi()
var opts = { 
  'body':  // {{DOCUMENTS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dOCUMENTSPost(opts, callback);

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

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

            var apiInstance = new DocumentsApi();
            var body = new DOCUMENTS(); // DOCUMENTS |  (optional) 

            try
            {
                // upload a new documents Meta data into database
                DOCUMENTS result = apiInstance.dOCUMENTSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.dOCUMENTSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDocumentsApi();
$body = ; // DOCUMENTS | 

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

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

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

eval { 
    my $result = $api_instance->dOCUMENTSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentsApi->dOCUMENTSPost: $@\n";
}

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

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

try: 
    # upload a new documents Meta data into database
    api_response = api_instance.d_ocuments_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentsApi->dOCUMENTSPost: %s\n" % e)

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

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

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        DOCUMENTS body = ; // DOCUMENTS | 
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        DOCUMENTS body = ; // DOCUMENTS | 
        Integer id = 56; // Integer | 
        try {
            DOCUMENTS result = apiInstance.dOCUMENTSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#dOCUMENTSPut");
            e.printStackTrace();
        }
    }
}

DOCUMENTS *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update Meta data of a specific document
[apiInstance dOCUMENTSPutWith:body
    id:id
              completionHandler: ^(DOCUMENTS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.DocumentsApi()
var opts = { 
  'body':  // {{DOCUMENTS}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dOCUMENTSPut(opts, callback);

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

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

            var apiInstance = new DocumentsApi();
            var body = new DOCUMENTS(); // DOCUMENTS |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update Meta data of a specific document
                DOCUMENTS result = apiInstance.dOCUMENTSPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.dOCUMENTSPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDocumentsApi();
$body = ; // DOCUMENTS | 
$id = 56; // Integer | 

try {
    $result = $api_instance->dOCUMENTSPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->dOCUMENTSPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $body = WWW::SwaggerClient::Object::DOCUMENTS->new(); # DOCUMENTS | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->dOCUMENTSPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentsApi->dOCUMENTSPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
body =  # DOCUMENTS |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update Meta data of a specific document
    api_response = api_instance.d_ocuments_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentsApi->dOCUMENTSPut: %s\n" % e)

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

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

public class FAQApiExample {

    public static void main(String[] args) {
        
        FAQApi apiInstance = new FAQApi();
        try {
            array[FAQ] result = apiInstance.fAQGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FAQApi;

public class FAQApiExample {

    public static void main(String[] args) {
        FAQApi apiInstance = new FAQApi();
        try {
            array[FAQ] result = apiInstance.fAQGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQGet");
            e.printStackTrace();
        }
    }
}

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

// Show list of complete FAQ database questions and answers
[apiInstance fAQGetWithCompletionHandler: 
              ^(array[FAQ] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.FAQApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fAQGet(callback);

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

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

            var apiInstance = new FAQApi();

            try
            {
                // Show list of complete FAQ database questions and answers
                array[FAQ] result = apiInstance.fAQGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FAQApi.fAQGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFAQApi();

try {
    $result = $api_instance->fAQGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FAQApi->fAQGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::FAQApi->new();

eval { 
    my $result = $api_instance->fAQGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FAQApi->fAQGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FAQApi()

try: 
    # Show list of complete FAQ database questions and answers
    api_response = api_instance.f_aq_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FAQApi->fAQGet: %s\n" % e)

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

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

public class FAQApiExample {

    public static void main(String[] args) {
        
        FAQApi apiInstance = new FAQApi();
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FAQApi;

public class FAQApiExample {

    public static void main(String[] args) {
        FAQApi apiInstance = new FAQApi();
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove question and answer from FAQ Database
[apiInstance fAQIdDeleteWith:id
              completionHandler: ^(FAQ output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.FAQApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new FAQApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove question and answer from FAQ Database
                FAQ result = apiInstance.fAQIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FAQApi.fAQIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFAQApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->fAQIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FAQApi->fAQIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::FAQApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->fAQIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FAQApi->fAQIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FAQApi()
id = 56 # Integer | 

try: 
    # Remove question and answer from FAQ Database
    api_response = api_instance.f_aqid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FAQApi->fAQIdDelete: %s\n" % e)

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

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

public class FAQApiExample {

    public static void main(String[] args) {
        
        FAQApi apiInstance = new FAQApi();
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FAQApi;

public class FAQApiExample {

    public static void main(String[] args) {
        FAQApi apiInstance = new FAQApi();
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific question and answer
[apiInstance fAQIdGetWith:id
              completionHandler: ^(FAQ output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.FAQApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new FAQApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific question and answer
                FAQ result = apiInstance.fAQIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FAQApi.fAQIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFAQApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->fAQIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FAQApi->fAQIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::FAQApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->fAQIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FAQApi->fAQIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FAQApi()
id = 56 # Integer | 

try: 
    # Search for a specific question and answer
    api_response = api_instance.f_aqid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FAQApi->fAQIdGet: %s\n" % e)

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

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

public class FAQApiExample {

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

import io.swagger.client.api.FAQApi;

public class FAQApiExample {

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

FAQ *body = ; //  (optional)

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

// Submit a new question and answer to FAQ database
[apiInstance fAQPostWith:body
              completionHandler: ^(FAQ output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.FAQApi()
var opts = { 
  'body':  // {{FAQ}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fAQPost(opts, callback);

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

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

            var apiInstance = new FAQApi();
            var body = new FAQ(); // FAQ |  (optional) 

            try
            {
                // Submit a new question and answer to FAQ database
                FAQ result = apiInstance.fAQPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FAQApi.fAQPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFAQApi();
$body = ; // FAQ | 

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

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

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

eval { 
    my $result = $api_instance->fAQPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FAQApi->fAQPost: $@\n";
}

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

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

try: 
    # Submit a new question and answer to FAQ database
    api_response = api_instance.f_aq_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FAQApi->fAQPost: %s\n" % e)

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

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

public class FAQApiExample {

    public static void main(String[] args) {
        
        FAQApi apiInstance = new FAQApi();
        FAQ body = ; // FAQ | 
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FAQApi;

public class FAQApiExample {

    public static void main(String[] args) {
        FAQApi apiInstance = new FAQApi();
        FAQ body = ; // FAQ | 
        Integer id = 56; // Integer | 
        try {
            FAQ result = apiInstance.fAQPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FAQApi#fAQPut");
            e.printStackTrace();
        }
    }
}

FAQ *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update a question or answer in FAQ database
[apiInstance fAQPutWith:body
    id:id
              completionHandler: ^(FAQ output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.FAQApi()
var opts = { 
  'body':  // {{FAQ}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fAQPut(opts, callback);

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

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

            var apiInstance = new FAQApi();
            var body = new FAQ(); // FAQ |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update a question or answer in FAQ database
                FAQ result = apiInstance.fAQPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FAQApi.fAQPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiFAQApi();
$body = ; // FAQ | 
$id = 56; // Integer | 

try {
    $result = $api_instance->fAQPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FAQApi->fAQPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::FAQApi->new();
my $body = WWW::SwaggerClient::Object::FAQ->new(); # FAQ | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->fAQPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FAQApi->fAQPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.FAQApi()
body =  # FAQ |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update a question or answer in FAQ database
    api_response = api_instance.f_aq_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FAQApi->fAQPut: %s\n" % e)

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

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

public class GradeApiExample {

    public static void main(String[] args) {
        
        GradeApi apiInstance = new GradeApi();
        try {
            array[GRADE] result = apiInstance.gRADEGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GradeApi;

public class GradeApiExample {

    public static void main(String[] args) {
        GradeApi apiInstance = new GradeApi();
        try {
            array[GRADE] result = apiInstance.gRADEGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEGet");
            e.printStackTrace();
        }
    }
}

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

// Get a list of all grades available
[apiInstance gRADEGetWithCompletionHandler: 
              ^(array[GRADE] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.GradeApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gRADEGet(callback);

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

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

            var apiInstance = new GradeApi();

            try
            {
                // Get a list of all grades available
                array[GRADE] result = apiInstance.gRADEGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GradeApi.gRADEGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGradeApi();

try {
    $result = $api_instance->gRADEGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GradeApi->gRADEGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::GradeApi->new();

eval { 
    my $result = $api_instance->gRADEGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GradeApi->gRADEGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GradeApi()

try: 
    # Get a list of all grades available
    api_response = api_instance.g_rade_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GradeApi->gRADEGet: %s\n" % e)

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

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

public class GradeApiExample {

    public static void main(String[] args) {
        
        GradeApi apiInstance = new GradeApi();
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GradeApi;

public class GradeApiExample {

    public static void main(String[] args) {
        GradeApi apiInstance = new GradeApi();
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove grade information
[apiInstance gRADEIdDeleteWith:id
              completionHandler: ^(GRADE output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.GradeApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new GradeApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove grade information
                GRADE result = apiInstance.gRADEIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GradeApi.gRADEIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGradeApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->gRADEIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GradeApi->gRADEIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::GradeApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->gRADEIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GradeApi->gRADEIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GradeApi()
id = 56 # Integer | 

try: 
    # Remove grade information
    api_response = api_instance.g_radeid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GradeApi->gRADEIdDelete: %s\n" % e)

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

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

public class GradeApiExample {

    public static void main(String[] args) {
        
        GradeApi apiInstance = new GradeApi();
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GradeApi;

public class GradeApiExample {

    public static void main(String[] args) {
        GradeApi apiInstance = new GradeApi();
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific grade
[apiInstance gRADEIdGetWith:id
              completionHandler: ^(GRADE output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.GradeApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new GradeApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific grade
                GRADE result = apiInstance.gRADEIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GradeApi.gRADEIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGradeApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->gRADEIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GradeApi->gRADEIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::GradeApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->gRADEIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GradeApi->gRADEIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GradeApi()
id = 56 # Integer | 

try: 
    # Search for a specific grade
    api_response = api_instance.g_radeid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GradeApi->gRADEIdGet: %s\n" % e)

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

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

public class GradeApiExample {

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

import io.swagger.client.api.GradeApi;

public class GradeApiExample {

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

GRADE *body = ; //  (optional)

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

// Add a new grade to list
[apiInstance gRADEPostWith:body
              completionHandler: ^(GRADE output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.GradeApi()
var opts = { 
  'body':  // {{GRADE}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gRADEPost(opts, callback);

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

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

            var apiInstance = new GradeApi();
            var body = new GRADE(); // GRADE |  (optional) 

            try
            {
                // Add a new grade to list
                GRADE result = apiInstance.gRADEPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GradeApi.gRADEPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGradeApi();
$body = ; // GRADE | 

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

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

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

eval { 
    my $result = $api_instance->gRADEPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GradeApi->gRADEPost: $@\n";
}

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

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

try: 
    # Add a new grade to list
    api_response = api_instance.g_rade_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GradeApi->gRADEPost: %s\n" % e)

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

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

public class GradeApiExample {

    public static void main(String[] args) {
        
        GradeApi apiInstance = new GradeApi();
        GRADE body = ; // GRADE | 
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GradeApi;

public class GradeApiExample {

    public static void main(String[] args) {
        GradeApi apiInstance = new GradeApi();
        GRADE body = ; // GRADE | 
        Integer id = 56; // Integer | 
        try {
            GRADE result = apiInstance.gRADEPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GradeApi#gRADEPut");
            e.printStackTrace();
        }
    }
}

GRADE *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update grade information
[apiInstance gRADEPutWith:body
    id:id
              completionHandler: ^(GRADE output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.GradeApi()
var opts = { 
  'body':  // {{GRADE}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gRADEPut(opts, callback);

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

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

            var apiInstance = new GradeApi();
            var body = new GRADE(); // GRADE |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update grade information
                GRADE result = apiInstance.gRADEPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GradeApi.gRADEPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGradeApi();
$body = ; // GRADE | 
$id = 56; // Integer | 

try {
    $result = $api_instance->gRADEPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GradeApi->gRADEPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::GradeApi->new();
my $body = WWW::SwaggerClient::Object::GRADE->new(); # GRADE | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->gRADEPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GradeApi->gRADEPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GradeApi()
body =  # GRADE |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update grade information
    api_response = api_instance.g_rade_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GradeApi->gRADEPut: %s\n" % e)

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

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

public class ModerationsApiExample {

    public static void main(String[] args) {
        
        ModerationsApi apiInstance = new ModerationsApi();
        try {
            array[MODERATIONS] result = apiInstance.mODERATIONSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ModerationsApi;

public class ModerationsApiExample {

    public static void main(String[] args) {
        ModerationsApi apiInstance = new ModerationsApi();
        try {
            array[MODERATIONS] result = apiInstance.mODERATIONSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSGet");
            e.printStackTrace();
        }
    }
}

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

// Get list of all document moderations and status
[apiInstance mODERATIONSGetWithCompletionHandler: 
              ^(array[MODERATIONS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.ModerationsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mODERATIONSGet(callback);

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

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

            var apiInstance = new ModerationsApi();

            try
            {
                // Get list of all document moderations and status
                array[MODERATIONS] result = apiInstance.mODERATIONSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModerationsApi.mODERATIONSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiModerationsApi();

try {
    $result = $api_instance->mODERATIONSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModerationsApi->mODERATIONSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ModerationsApi->new();

eval { 
    my $result = $api_instance->mODERATIONSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModerationsApi->mODERATIONSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ModerationsApi()

try: 
    # Get list of all document moderations and status
    api_response = api_instance.m_oderations_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModerationsApi->mODERATIONSGet: %s\n" % e)

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

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

public class ModerationsApiExample {

    public static void main(String[] args) {
        
        ModerationsApi apiInstance = new ModerationsApi();
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ModerationsApi;

public class ModerationsApiExample {

    public static void main(String[] args) {
        ModerationsApi apiInstance = new ModerationsApi();
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove document moderation
[apiInstance mODERATIONSIdDeleteWith:id
              completionHandler: ^(MODERATIONS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.ModerationsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new ModerationsApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove document moderation
                MODERATIONS result = apiInstance.mODERATIONSIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModerationsApi.mODERATIONSIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiModerationsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->mODERATIONSIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModerationsApi->mODERATIONSIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ModerationsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->mODERATIONSIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModerationsApi->mODERATIONSIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ModerationsApi()
id = 56 # Integer | 

try: 
    # Remove document moderation
    api_response = api_instance.m_oderationsid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModerationsApi->mODERATIONSIdDelete: %s\n" % e)

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

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

public class ModerationsApiExample {

    public static void main(String[] args) {
        
        ModerationsApi apiInstance = new ModerationsApi();
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ModerationsApi;

public class ModerationsApiExample {

    public static void main(String[] args) {
        ModerationsApi apiInstance = new ModerationsApi();
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for moderation information for a specific document
[apiInstance mODERATIONSIdGetWith:id
              completionHandler: ^(MODERATIONS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.ModerationsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new ModerationsApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for moderation information for a specific document
                MODERATIONS result = apiInstance.mODERATIONSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModerationsApi.mODERATIONSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiModerationsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->mODERATIONSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModerationsApi->mODERATIONSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ModerationsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->mODERATIONSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModerationsApi->mODERATIONSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ModerationsApi()
id = 56 # Integer | 

try: 
    # Search for moderation information for a specific document
    api_response = api_instance.m_oderationsid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModerationsApi->mODERATIONSIdGet: %s\n" % e)

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

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

public class ModerationsApiExample {

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

import io.swagger.client.api.ModerationsApi;

public class ModerationsApiExample {

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

MODERATIONS *body = ; //  (optional)

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

// Add a new document moderation
[apiInstance mODERATIONSPostWith:body
              completionHandler: ^(MODERATIONS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.ModerationsApi()
var opts = { 
  'body':  // {{MODERATIONS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mODERATIONSPost(opts, callback);

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

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

            var apiInstance = new ModerationsApi();
            var body = new MODERATIONS(); // MODERATIONS |  (optional) 

            try
            {
                // Add a new document moderation
                MODERATIONS result = apiInstance.mODERATIONSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModerationsApi.mODERATIONSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiModerationsApi();
$body = ; // MODERATIONS | 

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

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

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

eval { 
    my $result = $api_instance->mODERATIONSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModerationsApi->mODERATIONSPost: $@\n";
}

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

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

try: 
    # Add a new document moderation
    api_response = api_instance.m_oderations_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModerationsApi->mODERATIONSPost: %s\n" % e)

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

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

public class ModerationsApiExample {

    public static void main(String[] args) {
        
        ModerationsApi apiInstance = new ModerationsApi();
        MODERATIONS body = ; // MODERATIONS | 
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ModerationsApi;

public class ModerationsApiExample {

    public static void main(String[] args) {
        ModerationsApi apiInstance = new ModerationsApi();
        MODERATIONS body = ; // MODERATIONS | 
        Integer id = 56; // Integer | 
        try {
            MODERATIONS result = apiInstance.mODERATIONSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ModerationsApi#mODERATIONSPut");
            e.printStackTrace();
        }
    }
}

MODERATIONS *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update document moderation status and comment
[apiInstance mODERATIONSPutWith:body
    id:id
              completionHandler: ^(MODERATIONS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.ModerationsApi()
var opts = { 
  'body':  // {{MODERATIONS}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mODERATIONSPut(opts, callback);

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

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

            var apiInstance = new ModerationsApi();
            var body = new MODERATIONS(); // MODERATIONS |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update document moderation status and comment
                MODERATIONS result = apiInstance.mODERATIONSPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ModerationsApi.mODERATIONSPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiModerationsApi();
$body = ; // MODERATIONS | 
$id = 56; // Integer | 

try {
    $result = $api_instance->mODERATIONSPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ModerationsApi->mODERATIONSPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ModerationsApi->new();
my $body = WWW::SwaggerClient::Object::MODERATIONS->new(); # MODERATIONS | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->mODERATIONSPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ModerationsApi->mODERATIONSPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ModerationsApi()
body =  # MODERATIONS |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update document moderation status and comment
    api_response = api_instance.m_oderations_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ModerationsApi->mODERATIONSPut: %s\n" % e)

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

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

public class RatingsApiExample {

    public static void main(String[] args) {
        
        RatingsApi apiInstance = new RatingsApi();
        try {
            array[RATINGS] result = apiInstance.rATINGSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RatingsApi;

public class RatingsApiExample {

    public static void main(String[] args) {
        RatingsApi apiInstance = new RatingsApi();
        try {
            array[RATINGS] result = apiInstance.rATINGSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSGet");
            e.printStackTrace();
        }
    }
}

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

// Get list of all available ratings
[apiInstance rATINGSGetWithCompletionHandler: 
              ^(array[RATINGS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RatingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rATINGSGet(callback);

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

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

            var apiInstance = new RatingsApi();

            try
            {
                // Get list of all available ratings
                array[RATINGS] result = apiInstance.rATINGSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RatingsApi.rATINGSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRatingsApi();

try {
    $result = $api_instance->rATINGSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RatingsApi->rATINGSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RatingsApi->new();

eval { 
    my $result = $api_instance->rATINGSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RatingsApi->rATINGSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RatingsApi()

try: 
    # Get list of all available ratings
    api_response = api_instance.r_atings_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RatingsApi->rATINGSGet: %s\n" % e)

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

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

public class RatingsApiExample {

    public static void main(String[] args) {
        
        RatingsApi apiInstance = new RatingsApi();
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RatingsApi;

public class RatingsApiExample {

    public static void main(String[] args) {
        RatingsApi apiInstance = new RatingsApi();
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove rating from list
[apiInstance rATINGSIdDeleteWith:id
              completionHandler: ^(RATINGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RatingsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new RatingsApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove rating from list
                RATINGS result = apiInstance.rATINGSIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RatingsApi.rATINGSIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRatingsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->rATINGSIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RatingsApi->rATINGSIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RatingsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rATINGSIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RatingsApi->rATINGSIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RatingsApi()
id = 56 # Integer | 

try: 
    # Remove rating from list
    api_response = api_instance.r_atingsid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RatingsApi->rATINGSIdDelete: %s\n" % e)

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

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

public class RatingsApiExample {

    public static void main(String[] args) {
        
        RatingsApi apiInstance = new RatingsApi();
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RatingsApi;

public class RatingsApiExample {

    public static void main(String[] args) {
        RatingsApi apiInstance = new RatingsApi();
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific rating
[apiInstance rATINGSIdGetWith:id
              completionHandler: ^(RATINGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RatingsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new RatingsApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific rating
                RATINGS result = apiInstance.rATINGSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RatingsApi.rATINGSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRatingsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->rATINGSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RatingsApi->rATINGSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RatingsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rATINGSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RatingsApi->rATINGSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RatingsApi()
id = 56 # Integer | 

try: 
    # Search for a specific rating
    api_response = api_instance.r_atingsid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RatingsApi->rATINGSIdGet: %s\n" % e)

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

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

public class RatingsApiExample {

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

import io.swagger.client.api.RatingsApi;

public class RatingsApiExample {

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

RATINGS *body = ; //  (optional)

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

// Add a new rating
[apiInstance rATINGSPostWith:body
              completionHandler: ^(RATINGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RatingsApi()
var opts = { 
  'body':  // {{RATINGS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rATINGSPost(opts, callback);

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

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

            var apiInstance = new RatingsApi();
            var body = new RATINGS(); // RATINGS |  (optional) 

            try
            {
                // Add a new rating
                RATINGS result = apiInstance.rATINGSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RatingsApi.rATINGSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRatingsApi();
$body = ; // RATINGS | 

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

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

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

eval { 
    my $result = $api_instance->rATINGSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RatingsApi->rATINGSPost: $@\n";
}

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

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

try: 
    # Add a new rating
    api_response = api_instance.r_atings_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RatingsApi->rATINGSPost: %s\n" % e)

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

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

public class RatingsApiExample {

    public static void main(String[] args) {
        
        RatingsApi apiInstance = new RatingsApi();
        RATINGS body = ; // RATINGS | 
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RatingsApi;

public class RatingsApiExample {

    public static void main(String[] args) {
        RatingsApi apiInstance = new RatingsApi();
        RATINGS body = ; // RATINGS | 
        Integer id = 56; // Integer | 
        try {
            RATINGS result = apiInstance.rATINGSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RatingsApi#rATINGSPut");
            e.printStackTrace();
        }
    }
}

RATINGS *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update rating information
[apiInstance rATINGSPutWith:body
    id:id
              completionHandler: ^(RATINGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RatingsApi()
var opts = { 
  'body':  // {{RATINGS}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rATINGSPut(opts, callback);

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

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

            var apiInstance = new RatingsApi();
            var body = new RATINGS(); // RATINGS |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update rating information
                RATINGS result = apiInstance.rATINGSPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RatingsApi.rATINGSPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRatingsApi();
$body = ; // RATINGS | 
$id = 56; // Integer | 

try {
    $result = $api_instance->rATINGSPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RatingsApi->rATINGSPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RatingsApi->new();
my $body = WWW::SwaggerClient::Object::RATINGS->new(); # RATINGS | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rATINGSPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RatingsApi->rATINGSPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RatingsApi()
body =  # RATINGS |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update rating information
    api_response = api_instance.r_atings_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RatingsApi->rATINGSPut: %s\n" % e)

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

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

public class RolesApiExample {

    public static void main(String[] args) {
        
        RolesApi apiInstance = new RolesApi();
        try {
            array[ROLES] result = apiInstance.rOLESGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RolesApi;

public class RolesApiExample {

    public static void main(String[] args) {
        RolesApi apiInstance = new RolesApi();
        try {
            array[ROLES] result = apiInstance.rOLESGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESGet");
            e.printStackTrace();
        }
    }
}

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

// Get list of all roles
[apiInstance rOLESGetWithCompletionHandler: 
              ^(array[ROLES] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RolesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rOLESGet(callback);

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

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

            var apiInstance = new RolesApi();

            try
            {
                // Get list of all roles
                array[ROLES] result = apiInstance.rOLESGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RolesApi.rOLESGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRolesApi();

try {
    $result = $api_instance->rOLESGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RolesApi->rOLESGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RolesApi->new();

eval { 
    my $result = $api_instance->rOLESGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RolesApi->rOLESGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RolesApi()

try: 
    # Get list of all roles
    api_response = api_instance.r_oles_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RolesApi->rOLESGet: %s\n" % e)

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

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

public class RolesApiExample {

    public static void main(String[] args) {
        
        RolesApi apiInstance = new RolesApi();
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RolesApi;

public class RolesApiExample {

    public static void main(String[] args) {
        RolesApi apiInstance = new RolesApi();
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Delete a role
[apiInstance rOLESIdDeleteWith:id
              completionHandler: ^(ROLES output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RolesApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new RolesApi();
            var id = 56;  // Integer | 

            try
            {
                // Delete a role
                ROLES result = apiInstance.rOLESIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RolesApi.rOLESIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRolesApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->rOLESIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RolesApi->rOLESIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RolesApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rOLESIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RolesApi->rOLESIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RolesApi()
id = 56 # Integer | 

try: 
    # Delete a role
    api_response = api_instance.r_olesid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RolesApi->rOLESIdDelete: %s\n" % e)

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

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

public class RolesApiExample {

    public static void main(String[] args) {
        
        RolesApi apiInstance = new RolesApi();
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RolesApi;

public class RolesApiExample {

    public static void main(String[] args) {
        RolesApi apiInstance = new RolesApi();
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific role
[apiInstance rOLESIdGetWith:id
              completionHandler: ^(ROLES output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RolesApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new RolesApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific role
                ROLES result = apiInstance.rOLESIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RolesApi.rOLESIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRolesApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->rOLESIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RolesApi->rOLESIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RolesApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rOLESIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RolesApi->rOLESIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RolesApi()
id = 56 # Integer | 

try: 
    # Search for a specific role
    api_response = api_instance.r_olesid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RolesApi->rOLESIdGet: %s\n" % e)

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

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

public class RolesApiExample {

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

import io.swagger.client.api.RolesApi;

public class RolesApiExample {

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

ROLES *body = ; //  (optional)

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

// Add new role
[apiInstance rOLESPostWith:body
              completionHandler: ^(ROLES output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RolesApi()
var opts = { 
  'body':  // {{ROLES}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rOLESPost(opts, callback);

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

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

            var apiInstance = new RolesApi();
            var body = new ROLES(); // ROLES |  (optional) 

            try
            {
                // Add new role
                ROLES result = apiInstance.rOLESPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RolesApi.rOLESPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRolesApi();
$body = ; // ROLES | 

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

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

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

eval { 
    my $result = $api_instance->rOLESPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RolesApi->rOLESPost: $@\n";
}

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

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

try: 
    # Add new role
    api_response = api_instance.r_oles_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RolesApi->rOLESPost: %s\n" % e)

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

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

public class RolesApiExample {

    public static void main(String[] args) {
        
        RolesApi apiInstance = new RolesApi();
        ROLES body = ; // ROLES | 
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RolesApi;

public class RolesApiExample {

    public static void main(String[] args) {
        RolesApi apiInstance = new RolesApi();
        ROLES body = ; // ROLES | 
        Integer id = 56; // Integer | 
        try {
            ROLES result = apiInstance.rOLESPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RolesApi#rOLESPut");
            e.printStackTrace();
        }
    }
}

ROLES *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update role information
[apiInstance rOLESPutWith:body
    id:id
              completionHandler: ^(ROLES output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.RolesApi()
var opts = { 
  'body':  // {{ROLES}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.rOLESPut(opts, callback);

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

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

            var apiInstance = new RolesApi();
            var body = new ROLES(); // ROLES |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update role information
                ROLES result = apiInstance.rOLESPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RolesApi.rOLESPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRolesApi();
$body = ; // ROLES | 
$id = 56; // Integer | 

try {
    $result = $api_instance->rOLESPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RolesApi->rOLESPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::RolesApi->new();
my $body = WWW::SwaggerClient::Object::ROLES->new(); # ROLES | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->rOLESPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RolesApi->rOLESPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RolesApi()
body =  # ROLES |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update role information
    api_response = api_instance.r_oles_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RolesApi->rOLESPut: %s\n" % e)

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

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

public class TagsApiExample {

    public static void main(String[] args) {
        
        TagsApi apiInstance = new TagsApi();
        try {
            array[TAGS] result = apiInstance.tAGSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TagsApi;

public class TagsApiExample {

    public static void main(String[] args) {
        TagsApi apiInstance = new TagsApi();
        try {
            array[TAGS] result = apiInstance.tAGSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSGet");
            e.printStackTrace();
        }
    }
}

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

// Get list of all tags
[apiInstance tAGSGetWithCompletionHandler: 
              ^(array[TAGS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.TagsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tAGSGet(callback);

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

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

            var apiInstance = new TagsApi();

            try
            {
                // Get list of all tags
                array[TAGS] result = apiInstance.tAGSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TagsApi.tAGSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTagsApi();

try {
    $result = $api_instance->tAGSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TagsApi->tAGSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::TagsApi->new();

eval { 
    my $result = $api_instance->tAGSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TagsApi->tAGSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.TagsApi()

try: 
    # Get list of all tags
    api_response = api_instance.t_ags_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TagsApi->tAGSGet: %s\n" % e)

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

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

public class TagsApiExample {

    public static void main(String[] args) {
        
        TagsApi apiInstance = new TagsApi();
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TagsApi;

public class TagsApiExample {

    public static void main(String[] args) {
        TagsApi apiInstance = new TagsApi();
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove tag from list
[apiInstance tAGSIdDeleteWith:id
              completionHandler: ^(TAGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.TagsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new TagsApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove tag from list
                TAGS result = apiInstance.tAGSIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TagsApi.tAGSIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTagsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->tAGSIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TagsApi->tAGSIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::TagsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->tAGSIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TagsApi->tAGSIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.TagsApi()
id = 56 # Integer | 

try: 
    # Remove tag from list
    api_response = api_instance.t_agsid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TagsApi->tAGSIdDelete: %s\n" % e)

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

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

public class TagsApiExample {

    public static void main(String[] args) {
        
        TagsApi apiInstance = new TagsApi();
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TagsApi;

public class TagsApiExample {

    public static void main(String[] args) {
        TagsApi apiInstance = new TagsApi();
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for specific tag
[apiInstance tAGSIdGetWith:id
              completionHandler: ^(TAGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.TagsApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new TagsApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for specific tag
                TAGS result = apiInstance.tAGSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TagsApi.tAGSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTagsApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->tAGSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TagsApi->tAGSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::TagsApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->tAGSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TagsApi->tAGSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.TagsApi()
id = 56 # Integer | 

try: 
    # Search for specific tag
    api_response = api_instance.t_agsid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TagsApi->tAGSIdGet: %s\n" % e)

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

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

public class TagsApiExample {

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

import io.swagger.client.api.TagsApi;

public class TagsApiExample {

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

TAGS *body = ; //  (optional)

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

// Add new tag
[apiInstance tAGSPostWith:body
              completionHandler: ^(TAGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.TagsApi()
var opts = { 
  'body':  // {{TAGS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tAGSPost(opts, callback);

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

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

            var apiInstance = new TagsApi();
            var body = new TAGS(); // TAGS |  (optional) 

            try
            {
                // Add new tag
                TAGS result = apiInstance.tAGSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TagsApi.tAGSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTagsApi();
$body = ; // TAGS | 

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

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

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

eval { 
    my $result = $api_instance->tAGSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TagsApi->tAGSPost: $@\n";
}

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

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

try: 
    # Add new tag
    api_response = api_instance.t_ags_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TagsApi->tAGSPost: %s\n" % e)

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

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

public class TagsApiExample {

    public static void main(String[] args) {
        
        TagsApi apiInstance = new TagsApi();
        TAGS body = ; // TAGS | 
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TagsApi;

public class TagsApiExample {

    public static void main(String[] args) {
        TagsApi apiInstance = new TagsApi();
        TAGS body = ; // TAGS | 
        Integer id = 56; // Integer | 
        try {
            TAGS result = apiInstance.tAGSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TagsApi#tAGSPut");
            e.printStackTrace();
        }
    }
}

TAGS *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update tag details
[apiInstance tAGSPutWith:body
    id:id
              completionHandler: ^(TAGS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.TagsApi()
var opts = { 
  'body':  // {{TAGS}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tAGSPut(opts, callback);

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

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

            var apiInstance = new TagsApi();
            var body = new TAGS(); // TAGS |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update tag details
                TAGS result = apiInstance.tAGSPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TagsApi.tAGSPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTagsApi();
$body = ; // TAGS | 
$id = 56; // Integer | 

try {
    $result = $api_instance->tAGSPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TagsApi->tAGSPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::TagsApi->new();
my $body = WWW::SwaggerClient::Object::TAGS->new(); # TAGS | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->tAGSPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TagsApi->tAGSPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.TagsApi()
body =  # TAGS |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update tag details
    api_response = api_instance.t_ags_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TagsApi->tAGSPut: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        try {
            array[USERS] result = apiInstance.uSERSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        try {
            array[USERS] result = apiInstance.uSERSGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSGet");
            e.printStackTrace();
        }
    }
}

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

// Get user list
[apiInstance uSERSGetWithCompletionHandler: 
              ^(array[USERS] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.UsersApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uSERSGet(callback);

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

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

            var apiInstance = new UsersApi();

            try
            {
                // Get user list
                array[USERS] result = apiInstance.uSERSGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.uSERSGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();

try {
    $result = $api_instance->uSERSGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->uSERSGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();

eval { 
    my $result = $api_instance->uSERSGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->uSERSGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.UsersApi()

try: 
    # Get user list
    api_response = api_instance.u_sers_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->uSERSGet: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSIdDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Remove user profile
[apiInstance uSERSIdDeleteWith:id
              completionHandler: ^(USERS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.UsersApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new UsersApi();
            var id = 56;  // Integer | 

            try
            {
                // Remove user profile
                USERS result = apiInstance.uSERSIdDelete(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.uSERSIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->uSERSIdDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->uSERSIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->uSERSIdDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->uSERSIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.UsersApi()
id = 56 # Integer | 

try: 
    # Remove user profile
    api_response = api_instance.u_sersid_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->uSERSIdDelete: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSIdGet");
            e.printStackTrace();
        }
    }
}

Integer *id = 56; // 

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

// Search for a specific user
[apiInstance uSERSIdGetWith:id
              completionHandler: ^(USERS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.UsersApi()
var id = 56; // {{Integer}} 

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

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

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

            var apiInstance = new UsersApi();
            var id = 56;  // Integer | 

            try
            {
                // Search for a specific user
                USERS result = apiInstance.uSERSIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.uSERSIdGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$id = 56; // Integer | 

try {
    $result = $api_instance->uSERSIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->uSERSIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->uSERSIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->uSERSIdGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.UsersApi()
id = 56 # Integer | 

try: 
    # Search for a specific user
    api_response = api_instance.u_sersid_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->uSERSIdGet: %s\n" % e)

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

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

public class UsersApiExample {

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

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

USERS *body = ; //  (optional)

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

// Add new user
[apiInstance uSERSPostWith:body
              completionHandler: ^(USERS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.UsersApi()
var opts = { 
  'body':  // {{USERS}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uSERSPost(opts, callback);

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

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

            var apiInstance = new UsersApi();
            var body = new USERS(); // USERS |  (optional) 

            try
            {
                // Add new user
                USERS result = apiInstance.uSERSPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.uSERSPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // USERS | 

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

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

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

eval { 
    my $result = $api_instance->uSERSPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->uSERSPost: $@\n";
}

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

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

try: 
    # Add new user
    api_response = api_instance.u_sers_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->uSERSPost: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        USERS body = ; // USERS | 
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        USERS body = ; // USERS | 
        Integer id = 56; // Integer | 
        try {
            USERS result = apiInstance.uSERSPut(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#uSERSPut");
            e.printStackTrace();
        }
    }
}

USERS *body = ; //  (optional)
Integer *id = 56; //  (optional)

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

// Update a user's details
[apiInstance uSERSPutWith:body
    id:id
              completionHandler: ^(USERS output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CcdShare2Teach = require('ccd_share2_teach');

var api = new CcdShare2Teach.UsersApi()
var opts = { 
  'body':  // {{USERS}} 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uSERSPut(opts, callback);

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

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

            var apiInstance = new UsersApi();
            var body = new USERS(); // USERS |  (optional) 
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Update a user's details
                USERS result = apiInstance.uSERSPut(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.uSERSPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // USERS | 
$id = 56; // Integer | 

try {
    $result = $api_instance->uSERSPut($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->uSERSPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $body = WWW::SwaggerClient::Object::USERS->new(); # USERS | 
my $id = 56; # Integer | 

eval { 
    my $result = $api_instance->uSERSPut(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->uSERSPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.UsersApi()
body =  # USERS |  (optional)
id = 56 # Integer |  (optional)

try: 
    # Update a user's details
    api_response = api_instance.u_sers_put(body=body, id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->uSERSPut: %s\n" % e)