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

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

public class ProjectApiExample {

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

import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

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

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

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

var ProjectManagerApi = require('project_manager_api');

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

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

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

            var apiInstance = new ProjectApi();

            try
            {
                // Get list of all projects
                array[Project] result = apiInstance.apiV1ProjectGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.apiV1ProjectGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->apiV1ProjectGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectApi->apiV1ProjectGet: $@\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.ProjectApi()

try: 
    # Get list of all projects
    api_response = api_instance.api_v1_project_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectApi->apiV1ProjectGet: %s\n" % e)

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

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

public class ProjectApiExample {

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

import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

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

Project *body = ; // 

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

// Create a new project
[apiInstance apiV1ProjectPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.ProjectApi()
var body = ; // {{Project}} 

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

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

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

            var apiInstance = new ProjectApi();
            var body = new Project(); // Project | 

            try
            {
                // Create a new project
                apiInstance.apiV1ProjectPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.apiV1ProjectPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Project | 

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

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

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

eval { 
    $api_instance->apiV1ProjectPost(body => $body);
};
if ($@) {
    warn "Exception when calling ProjectApi->apiV1ProjectPost: $@\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.ProjectApi()
body =  # Project | 

try: 
    # Create a new project
    api_instance.api_v1_project_post(body)
except ApiException as e:
    print("Exception when calling ProjectApi->apiV1ProjectPost: %s\n" % e)

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

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

public class ProjectApiExample {

    public static void main(String[] args) {
        
        ProjectApi apiInstance = new ProjectApi();
        Integer projectId = 56; // Integer | 
        try {
            apiInstance.apiV1ProjectProjectIdDelete(projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#apiV1ProjectProjectIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Integer projectId = 56; // Integer | 
        try {
            apiInstance.apiV1ProjectProjectIdDelete(projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#apiV1ProjectProjectIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *projectId = 56; // 

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

// Delete a project by ID
[apiInstance apiV1ProjectProjectIdDeleteWith:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.ProjectApi()
var projectId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new ProjectApi();
            var projectId = 56;  // Integer | 

            try
            {
                // Delete a project by ID
                apiInstance.apiV1ProjectProjectIdDelete(projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.apiV1ProjectProjectIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiProjectApi();
$projectId = 56; // Integer | 

try {
    $api_instance->apiV1ProjectProjectIdDelete($projectId);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->apiV1ProjectProjectIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->apiV1ProjectProjectIdDelete(projectId => $projectId);
};
if ($@) {
    warn "Exception when calling ProjectApi->apiV1ProjectProjectIdDelete: $@\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.ProjectApi()
projectId = 56 # Integer | 

try: 
    # Delete a project by ID
    api_instance.api_v1_project_project_id_delete(projectId)
except ApiException as e:
    print("Exception when calling ProjectApi->apiV1ProjectProjectIdDelete: %s\n" % e)

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

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

public class ProjectApiExample {

    public static void main(String[] args) {
        
        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        Integer projectId = 56; // Integer | 
        try {
            apiInstance.apiV1ProjectProjectIdPut(body, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#apiV1ProjectProjectIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        Integer projectId = 56; // Integer | 
        try {
            apiInstance.apiV1ProjectProjectIdPut(body, projectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#apiV1ProjectProjectIdPut");
            e.printStackTrace();
        }
    }
}

Project *body = ; // 
Integer *projectId = 56; // 

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

// Update a project by ID
[apiInstance apiV1ProjectProjectIdPutWith:body
    projectId:projectId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.ProjectApi()
var body = ; // {{Project}} 
var projectId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new ProjectApi();
            var body = new Project(); // Project | 
            var projectId = 56;  // Integer | 

            try
            {
                // Update a project by ID
                apiInstance.apiV1ProjectProjectIdPut(body, projectId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.apiV1ProjectProjectIdPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Project | 
$projectId = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $body = WWW::SwaggerClient::Object::Project->new(); # Project | 
my $projectId = 56; # Integer | 

eval { 
    $api_instance->apiV1ProjectProjectIdPut(body => $body, projectId => $projectId);
};
if ($@) {
    warn "Exception when calling ProjectApi->apiV1ProjectProjectIdPut: $@\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.ProjectApi()
body =  # Project | 
projectId = 56 # Integer | 

try: 
    # Update a project by ID
    api_instance.api_v1_project_project_id_put(body, projectId)
except ApiException as e:
    print("Exception when calling ProjectApi->apiV1ProjectProjectIdPut: %s\n" % e)

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

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

public class TaskApiExample {

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

import io.swagger.client.api.TaskApi;

public class TaskApiExample {

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

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

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

var ProjectManagerApi = require('project_manager_api');

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

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

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

            var apiInstance = new TaskApi();

            try
            {
                // Get list of all tasks
                array[Task] result = apiInstance.apiV1TaskGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaskApi.apiV1TaskGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval { 
    my $result = $api_instance->apiV1TaskGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TaskApi->apiV1TaskGet: $@\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.TaskApi()

try: 
    # Get list of all tasks
    api_response = api_instance.api_v1_task_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TaskApi->apiV1TaskGet: %s\n" % e)

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

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

public class TaskApiExample {

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

import io.swagger.client.api.TaskApi;

public class TaskApiExample {

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

Task *body = ; // 

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

// Create a new task
[apiInstance apiV1TaskPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.TaskApi()
var body = ; // {{Task}} 

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

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

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

            var apiInstance = new TaskApi();
            var body = new Task(); // Task | 

            try
            {
                // Create a new task
                apiInstance.apiV1TaskPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaskApi.apiV1TaskPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTaskApi();
$body = ; // Task | 

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

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

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

eval { 
    $api_instance->apiV1TaskPost(body => $body);
};
if ($@) {
    warn "Exception when calling TaskApi->apiV1TaskPost: $@\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.TaskApi()
body =  # Task | 

try: 
    # Create a new task
    api_instance.api_v1_task_post(body)
except ApiException as e:
    print("Exception when calling TaskApi->apiV1TaskPost: %s\n" % e)

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

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

public class TaskApiExample {

    public static void main(String[] args) {
        
        TaskApi apiInstance = new TaskApi();
        Integer taskId = 56; // Integer | 
        try {
            apiInstance.apiV1TaskTaskIdDelete(taskId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskApi#apiV1TaskTaskIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TaskApi;

public class TaskApiExample {

    public static void main(String[] args) {
        TaskApi apiInstance = new TaskApi();
        Integer taskId = 56; // Integer | 
        try {
            apiInstance.apiV1TaskTaskIdDelete(taskId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskApi#apiV1TaskTaskIdDelete");
            e.printStackTrace();
        }
    }
}

Integer *taskId = 56; // 

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

// Delete a task by ID
[apiInstance apiV1TaskTaskIdDeleteWith:taskId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.TaskApi()
var taskId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new TaskApi();
            var taskId = 56;  // Integer | 

            try
            {
                // Delete a task by ID
                apiInstance.apiV1TaskTaskIdDelete(taskId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaskApi.apiV1TaskTaskIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTaskApi();
$taskId = 56; // Integer | 

try {
    $api_instance->apiV1TaskTaskIdDelete($taskId);
} catch (Exception $e) {
    echo 'Exception when calling TaskApi->apiV1TaskTaskIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->apiV1TaskTaskIdDelete(taskId => $taskId);
};
if ($@) {
    warn "Exception when calling TaskApi->apiV1TaskTaskIdDelete: $@\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.TaskApi()
taskId = 56 # Integer | 

try: 
    # Delete a task by ID
    api_instance.api_v1_task_task_id_delete(taskId)
except ApiException as e:
    print("Exception when calling TaskApi->apiV1TaskTaskIdDelete: %s\n" % e)

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

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

public class TaskApiExample {

    public static void main(String[] args) {
        
        TaskApi apiInstance = new TaskApi();
        Task body = ; // Task | 
        Integer taskId = 56; // Integer | 
        try {
            apiInstance.apiV1TaskTaskIdPut(body, taskId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskApi#apiV1TaskTaskIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TaskApi;

public class TaskApiExample {

    public static void main(String[] args) {
        TaskApi apiInstance = new TaskApi();
        Task body = ; // Task | 
        Integer taskId = 56; // Integer | 
        try {
            apiInstance.apiV1TaskTaskIdPut(body, taskId);
        } catch (ApiException e) {
            System.err.println("Exception when calling TaskApi#apiV1TaskTaskIdPut");
            e.printStackTrace();
        }
    }
}

Task *body = ; // 
Integer *taskId = 56; // 

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

// Update a task by ID
[apiInstance apiV1TaskTaskIdPutWith:body
    taskId:taskId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.TaskApi()
var body = ; // {{Task}} 
var taskId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new TaskApi();
            var body = new Task(); // Task | 
            var taskId = 56;  // Integer | 

            try
            {
                // Update a task by ID
                apiInstance.apiV1TaskTaskIdPut(body, taskId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TaskApi.apiV1TaskTaskIdPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTaskApi();
$body = ; // Task | 
$taskId = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::TaskApi->new();
my $body = WWW::SwaggerClient::Object::Task->new(); # Task | 
my $taskId = 56; # Integer | 

eval { 
    $api_instance->apiV1TaskTaskIdPut(body => $body, taskId => $taskId);
};
if ($@) {
    warn "Exception when calling TaskApi->apiV1TaskTaskIdPut: $@\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.TaskApi()
body =  # Task | 
taskId = 56 # Integer | 

try: 
    # Update a task by ID
    api_instance.api_v1_task_task_id_put(body, taskId)
except ApiException as e:
    print("Exception when calling TaskApi->apiV1TaskTaskIdPut: %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();
        V1_login_body body = ; // V1_login_body | 
        try {
            apiInstance.apiV1LoginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1LoginPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

V1_login_body *body = ; // 

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

// User login
[apiInstance apiV1LoginPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.UsersApi()
var body = ; // {{V1_login_body}} 

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

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

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

            var apiInstance = new UsersApi();
            var body = new V1_login_body(); // V1_login_body | 

            try
            {
                // User login
                apiInstance.apiV1LoginPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.apiV1LoginPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // V1_login_body | 

try {
    $api_instance->apiV1LoginPost($body);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->apiV1LoginPost: ', $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::V1_login_body->new(); # V1_login_body | 

eval { 
    $api_instance->apiV1LoginPost(body => $body);
};
if ($@) {
    warn "Exception when calling UsersApi->apiV1LoginPost: $@\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 =  # V1_login_body | 

try: 
    # User login
    api_instance.api_v1_login_post(body)
except ApiException as e:
    print("Exception when calling UsersApi->apiV1LoginPost: %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 userId = 56; // Integer | 
        try {
            apiInstance.apiV1UserDelete(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1UserDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

Integer *userId = 56; // 

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

// Delete a user by ID
[apiInstance apiV1UserDeleteWith:userId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.UsersApi()
var userId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new UsersApi();
            var userId = 56;  // Integer | 

            try
            {
                // Delete a user by ID
                apiInstance.apiV1UserDelete(userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.apiV1UserDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$userId = 56; // Integer | 

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

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

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

eval { 
    $api_instance->apiV1UserDelete(userId => $userId);
};
if ($@) {
    warn "Exception when calling UsersApi->apiV1UserDelete: $@\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()
userId = 56 # Integer | 

try: 
    # Delete a user by ID
    api_instance.api_v1_user_delete(userId)
except ApiException as e:
    print("Exception when calling UsersApi->apiV1UserDelete: %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[User] result = apiInstance.apiV1UserGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1UserGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

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

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

var ProjectManagerApi = require('project_manager_api');

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

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

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

            var apiInstance = new UsersApi();

            try
            {
                // Get list of all users
                array[User] result = apiInstance.apiV1UserGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.apiV1UserGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->apiV1UserGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->apiV1UserGet: ', $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->apiV1UserGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->apiV1UserGet: $@\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 list of all users
    api_response = api_instance.api_v1_user_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->apiV1UserGet: %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();
        User body = ; // User | 
        try {
            apiInstance.apiV1UserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1UserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

User *body = ; // 

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

// Create a new user
[apiInstance apiV1UserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.UsersApi()
var body = ; // {{User}} 

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

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

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

            var apiInstance = new UsersApi();
            var body = new User(); // User | 

            try
            {
                // Create a new user
                apiInstance.apiV1UserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.apiV1UserPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // User | 

try {
    $api_instance->apiV1UserPost($body);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->apiV1UserPost: ', $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::User->new(); # User | 

eval { 
    $api_instance->apiV1UserPost(body => $body);
};
if ($@) {
    warn "Exception when calling UsersApi->apiV1UserPost: $@\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 =  # User | 

try: 
    # Create a new user
    api_instance.api_v1_user_post(body)
except ApiException as e:
    print("Exception when calling UsersApi->apiV1UserPost: %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();
        User body = ; // User | 
        Integer userId = 56; // Integer | 
        try {
            apiInstance.apiV1UserPut(body, userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1UserPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        User body = ; // User | 
        Integer userId = 56; // Integer | 
        try {
            apiInstance.apiV1UserPut(body, userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#apiV1UserPut");
            e.printStackTrace();
        }
    }
}

User *body = ; // 
Integer *userId = 56; // 

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

// Update a user by ID
[apiInstance apiV1UserPutWith:body
    userId:userId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProjectManagerApi = require('project_manager_api');

var api = new ProjectManagerApi.UsersApi()
var body = ; // {{User}} 
var userId = 56; // {{Integer}} 

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

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

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

            var apiInstance = new UsersApi();
            var body = new User(); // User | 
            var userId = 56;  // Integer | 

            try
            {
                // Update a user by ID
                apiInstance.apiV1UserPut(body, userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.apiV1UserPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiUsersApi();
$body = ; // User | 
$userId = 56; // Integer | 

try {
    $api_instance->apiV1UserPut($body, $userId);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->apiV1UserPut: ', $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::User->new(); # User | 
my $userId = 56; # Integer | 

eval { 
    $api_instance->apiV1UserPut(body => $body, userId => $userId);
};
if ($@) {
    warn "Exception when calling UsersApi->apiV1UserPut: $@\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 =  # User | 
userId = 56 # Integer | 

try: 
    # Update a user by ID
    api_instance.api_v1_user_put(body, userId)
except ApiException as e:
    print("Exception when calling UsersApi->apiV1UserPut: %s\n" % e)