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

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

public class BooksApiExample {

    public static void main(String[] args) {
        
        BooksApi apiInstance = new BooksApi();
        Book book = ; // Book | book to create
        try {
            Object result = apiInstance.books.create(book);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BooksApi;

public class BooksApiExample {

    public static void main(String[] args) {
        BooksApi apiInstance = new BooksApi();
        Book book = ; // Book | book to create
        try {
            Object result = apiInstance.books.create(book);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.create");
            e.printStackTrace();
        }
    }
}

Book *book = ; // book to create

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

// Create a book
[apiInstance books.createWith:book
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.BooksApi()

var book = ; // {Book} book to create


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

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

namespace Example
{
    public class books.createExample
    {
        public void main()
        {
            
            var apiInstance = new BooksApi();
            var book = new Book(); // Book | book to create

            try
            {
                // Create a book
                Object result = apiInstance.books.create(book);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BooksApi.books.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BooksApi();
$book = ; // Book | book to create

try {
    $result = $api_instance->books.create($book);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BooksApi->books.create: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BooksApi->new();
my $book = WWW::SwaggerClient::Object::Book->new(); # Book | book to create

eval { 
    my $result = $api_instance->books.create(book => $book);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BooksApi->books.create: $@\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.BooksApi()
book =  # Book | book to create

try: 
    # Create a book
    api_response = api_instance.books/create(book)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BooksApi->books.create: %s\n" % e)

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

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

public class BooksApiExample {

    public static void main(String[] args) {
        
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn of the book to delete
        try {
            apiInstance.books.delete(isbn);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BooksApi;

public class BooksApiExample {

    public static void main(String[] args) {
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn of the book to delete
        try {
            apiInstance.books.delete(isbn);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.delete");
            e.printStackTrace();
        }
    }
}

Integer *isbn = 56; // isbn of the book to delete

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

// Delete a book from the books list
[apiInstance books.deleteWith:isbn
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.BooksApi()

var isbn = 56; // {Integer} isbn of the book to delete


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

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

namespace Example
{
    public class books.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new BooksApi();
            var isbn = 56;  // Integer | isbn of the book to delete

            try
            {
                // Delete a book from the books list
                apiInstance.books.delete(isbn);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BooksApi.books.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BooksApi();
$isbn = 56; // Integer | isbn of the book to delete

try {
    $api_instance->books.delete($isbn);
} catch (Exception $e) {
    echo 'Exception when calling BooksApi->books.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BooksApi->new();
my $isbn = 56; # Integer | isbn of the book to delete

eval { 
    $api_instance->books.delete(isbn => $isbn);
};
if ($@) {
    warn "Exception when calling BooksApi->books.delete: $@\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.BooksApi()
isbn = 56 # Integer | isbn of the book to delete

try: 
    # Delete a book from the books list
    api_instance.books/delete(isbn)
except ApiException as e:
    print("Exception when calling BooksApi->books.delete: %s\n" % e)

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

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

public class BooksApiExample {

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

import io.swagger.client.api.BooksApi;

public class BooksApiExample {

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

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

// Read the entire set of books, sorted by title
[apiInstance books.readAllWithCompletionHandler: 
              ^(array[inline_response_200_3] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.BooksApi()

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

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

namespace Example
{
    public class books.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new BooksApi();

            try
            {
                // Read the entire set of books, sorted by title
                array[inline_response_200_3] result = apiInstance.books.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BooksApi.books.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BooksApi();

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

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

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

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

try: 
    # Read the entire set of books, sorted by title
    api_response = api_instance.books/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BooksApi->books.readAll: %s\n" % e)

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

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

public class BooksApiExample {

    public static void main(String[] args) {
        
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn of the book to get
        try {
            inline_response_200_3 result = apiInstance.books.readOne(isbn);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BooksApi;

public class BooksApiExample {

    public static void main(String[] args) {
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn of the book to get
        try {
            inline_response_200_3 result = apiInstance.books.readOne(isbn);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.readOne");
            e.printStackTrace();
        }
    }
}

Integer *isbn = 56; // isbn of the book to get

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

// Read one book
[apiInstance books.readOneWith:isbn
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.BooksApi()

var isbn = 56; // {Integer} isbn of the book to get


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

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

namespace Example
{
    public class books.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new BooksApi();
            var isbn = 56;  // Integer | isbn of the book to get

            try
            {
                // Read one book
                inline_response_200_3 result = apiInstance.books.readOne(isbn);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BooksApi.books.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BooksApi();
$isbn = 56; // Integer | isbn of the book to get

try {
    $result = $api_instance->books.readOne($isbn);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BooksApi->books.readOne: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BooksApi->new();
my $isbn = 56; # Integer | isbn of the book to get

eval { 
    my $result = $api_instance->books.readOne(isbn => $isbn);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BooksApi->books.readOne: $@\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.BooksApi()
isbn = 56 # Integer | isbn of the book to get

try: 
    # Read one book
    api_response = api_instance.books/read_one(isbn)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BooksApi->books.readOne: %s\n" % e)

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

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

public class BooksApiExample {

    public static void main(String[] args) {
        
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn the book to update
        Book_1 book = ; // Book_1 | 
        try {
            Object result = apiInstance.books.update(isbn, book);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BooksApi;

public class BooksApiExample {

    public static void main(String[] args) {
        BooksApi apiInstance = new BooksApi();
        Integer isbn = 56; // Integer | isbn the book to update
        Book_1 book = ; // Book_1 | 
        try {
            Object result = apiInstance.books.update(isbn, book);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BooksApi#books.update");
            e.printStackTrace();
        }
    }
}

Integer *isbn = 56; // isbn the book to update
Book_1 *book = ; //  (optional)

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

// Update a book
[apiInstance books.updateWith:isbn
    book:book
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.BooksApi()

var isbn = 56; // {Integer} isbn the book to update

var opts = { 
  'book':  // {Book_1} 
};

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

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

namespace Example
{
    public class books.updateExample
    {
        public void main()
        {
            
            var apiInstance = new BooksApi();
            var isbn = 56;  // Integer | isbn the book to update
            var book = new Book_1(); // Book_1 |  (optional) 

            try
            {
                // Update a book
                Object result = apiInstance.books.update(isbn, book);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BooksApi.books.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BooksApi();
$isbn = 56; // Integer | isbn the book to update
$book = ; // Book_1 | 

try {
    $result = $api_instance->books.update($isbn, $book);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BooksApi->books.update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BooksApi->new();
my $isbn = 56; # Integer | isbn the book to update
my $book = WWW::SwaggerClient::Object::Book_1->new(); # Book_1 | 

eval { 
    my $result = $api_instance->books.update(isbn => $isbn, book => $book);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BooksApi->books.update: $@\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.BooksApi()
isbn = 56 # Integer | isbn the book to update
book =  # Book_1 |  (optional)

try: 
    # Update a book
    api_response = api_instance.books/update(isbn, book=book)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BooksApi->books.update: %s\n" % e)

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

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

public class MessagesApiExample {

    public static void main(String[] args) {
        
        MessagesApi apiInstance = new MessagesApi();
        Message message = ; // Message | message to create
        try {
            Object result = apiInstance.messages.create(message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MessagesApi;

public class MessagesApiExample {

    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        Message message = ; // Message | message to create
        try {
            Object result = apiInstance.messages.create(message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.create");
            e.printStackTrace();
        }
    }
}

Message *message = ; // message to create

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

// Create a message
[apiInstance messages.createWith:message
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.MessagesApi()

var message = ; // {Message} message to create


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

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

namespace Example
{
    public class messages.createExample
    {
        public void main()
        {
            
            var apiInstance = new MessagesApi();
            var message = new Message(); // Message | message to create

            try
            {
                // Create a message
                Object result = apiInstance.messages.create(message);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MessagesApi.messages.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MessagesApi();
$message = ; // Message | message to create

try {
    $result = $api_instance->messages.create($message);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagesApi->messages.create: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MessagesApi->new();
my $message = WWW::SwaggerClient::Object::Message->new(); # Message | message to create

eval { 
    my $result = $api_instance->messages.create(message => $message);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagesApi->messages.create: $@\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.MessagesApi()
message =  # Message | message to create

try: 
    # Create a message
    api_response = api_instance.messages/create(message)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->messages.create: %s\n" % e)

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

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

public class MessagesApiExample {

    public static void main(String[] args) {
        
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id of the message to delete
        try {
            apiInstance.messages.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MessagesApi;

public class MessagesApiExample {

    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id of the message to delete
        try {
            apiInstance.messages.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.delete");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the message to delete

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

// Delete a message from the messages list
[apiInstance messages.deleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.MessagesApi()

var id = id_example; // {String} id of the message to delete


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

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

namespace Example
{
    public class messages.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new MessagesApi();
            var id = id_example;  // String | id of the message to delete

            try
            {
                // Delete a message from the messages list
                apiInstance.messages.delete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MessagesApi.messages.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MessagesApi();
$id = id_example; // String | id of the message to delete

try {
    $api_instance->messages.delete($id);
} catch (Exception $e) {
    echo 'Exception when calling MessagesApi->messages.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MessagesApi->new();
my $id = id_example; # String | id of the message to delete

eval { 
    $api_instance->messages.delete(id => $id);
};
if ($@) {
    warn "Exception when calling MessagesApi->messages.delete: $@\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.MessagesApi()
id = id_example # String | id of the message to delete

try: 
    # Delete a message from the messages list
    api_instance.messages/delete(id)
except ApiException as e:
    print("Exception when calling MessagesApi->messages.delete: %s\n" % e)

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

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

public class MessagesApiExample {

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

import io.swagger.client.api.MessagesApi;

public class MessagesApiExample {

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

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

// Read the entire set of messages, sorted by date
[apiInstance messages.readAllWithCompletionHandler: 
              ^(array[inline_response_200_5] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.MessagesApi()

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

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

namespace Example
{
    public class messages.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new MessagesApi();

            try
            {
                // Read the entire set of messages, sorted by date
                array[inline_response_200_5] result = apiInstance.messages.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MessagesApi.messages.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MessagesApi();

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

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

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

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

try: 
    # Read the entire set of messages, sorted by date
    api_response = api_instance.messages/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->messages.readAll: %s\n" % e)

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

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

public class MessagesApiExample {

    public static void main(String[] args) {
        
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id of the message to get
        try {
            inline_response_200_5 result = apiInstance.messages.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MessagesApi;

public class MessagesApiExample {

    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id of the message to get
        try {
            inline_response_200_5 result = apiInstance.messages.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.readOne");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the message to get

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

// Read one message
[apiInstance messages.readOneWith:id
              completionHandler: ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.MessagesApi()

var id = id_example; // {String} id of the message to get


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

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

namespace Example
{
    public class messages.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new MessagesApi();
            var id = id_example;  // String | id of the message to get

            try
            {
                // Read one message
                inline_response_200_5 result = apiInstance.messages.readOne(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MessagesApi.messages.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MessagesApi();
$id = id_example; // String | id of the message to get

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

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

my $api_instance = WWW::SwaggerClient::MessagesApi->new();
my $id = id_example; # String | id of the message to get

eval { 
    my $result = $api_instance->messages.readOne(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagesApi->messages.readOne: $@\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.MessagesApi()
id = id_example # String | id of the message to get

try: 
    # Read one message
    api_response = api_instance.messages/read_one(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->messages.readOne: %s\n" % e)

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

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

public class MessagesApiExample {

    public static void main(String[] args) {
        
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id the message to update
        Message_1 message = ; // Message_1 | 
        try {
            Object result = apiInstance.messages.update(id, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MessagesApi;

public class MessagesApiExample {

    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        String id = id_example; // String | id the message to update
        Message_1 message = ; // Message_1 | 
        try {
            Object result = apiInstance.messages.update(id, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#messages.update");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id the message to update
Message_1 *message = ; //  (optional)

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

// Update a message
[apiInstance messages.updateWith:id
    message:message
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.MessagesApi()

var id = id_example; // {String} id the message to update

var opts = { 
  'message':  // {Message_1} 
};

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

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

namespace Example
{
    public class messages.updateExample
    {
        public void main()
        {
            
            var apiInstance = new MessagesApi();
            var id = id_example;  // String | id the message to update
            var message = new Message_1(); // Message_1 |  (optional) 

            try
            {
                // Update a message
                Object result = apiInstance.messages.update(id, message);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MessagesApi.messages.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MessagesApi();
$id = id_example; // String | id the message to update
$message = ; // Message_1 | 

try {
    $result = $api_instance->messages.update($id, $message);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagesApi->messages.update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MessagesApi->new();
my $id = id_example; # String | id the message to update
my $message = WWW::SwaggerClient::Object::Message_1->new(); # Message_1 | 

eval { 
    my $result = $api_instance->messages.update(id => $id, message => $message);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagesApi->messages.update: $@\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.MessagesApi()
id = id_example # String | id the message to update
message =  # Message_1 |  (optional)

try: 
    # Update a message
    api_response = api_instance.messages/update(id, message=message)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->messages.update: %s\n" % e)

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

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

public class PeopleApiExample {

    public static void main(String[] args) {
        
        PeopleApi apiInstance = new PeopleApi();
        Person person = ; // Person | Person to create
        try {
            Object result = apiInstance.people.create(person);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PeopleApi;

public class PeopleApiExample {

    public static void main(String[] args) {
        PeopleApi apiInstance = new PeopleApi();
        Person person = ; // Person | Person to create
        try {
            Object result = apiInstance.people.create(person);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.create");
            e.printStackTrace();
        }
    }
}

Person *person = ; // Person to create

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

// Create a person
[apiInstance people.createWith:person
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PeopleApi()

var person = ; // {Person} Person to create


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

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

namespace Example
{
    public class people.createExample
    {
        public void main()
        {
            
            var apiInstance = new PeopleApi();
            var person = new Person(); // Person | Person to create

            try
            {
                // Create a person
                Object result = apiInstance.people.create(person);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PeopleApi.people.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PeopleApi();
$person = ; // Person | Person to create

try {
    $result = $api_instance->people.create($person);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PeopleApi->people.create: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PeopleApi->new();
my $person = WWW::SwaggerClient::Object::Person->new(); # Person | Person to create

eval { 
    my $result = $api_instance->people.create(person => $person);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PeopleApi->people.create: $@\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.PeopleApi()
person =  # Person | Person to create

try: 
    # Create a person
    api_response = api_instance.people/create(person)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PeopleApi->people.create: %s\n" % e)

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

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

public class PeopleApiExample {

    public static void main(String[] args) {
        
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id of the person to delete
        try {
            apiInstance.people.delete(personId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PeopleApi;

public class PeopleApiExample {

    public static void main(String[] args) {
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id of the person to delete
        try {
            apiInstance.people.delete(personId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.delete");
            e.printStackTrace();
        }
    }
}

Integer *personId = 56; // Id of the person to delete

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

// Delete a person from the people list
[apiInstance people.deleteWith:personId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PeopleApi()

var personId = 56; // {Integer} Id of the person to delete


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

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

namespace Example
{
    public class people.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new PeopleApi();
            var personId = 56;  // Integer | Id of the person to delete

            try
            {
                // Delete a person from the people list
                apiInstance.people.delete(personId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PeopleApi.people.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PeopleApi();
$personId = 56; // Integer | Id of the person to delete

try {
    $api_instance->people.delete($personId);
} catch (Exception $e) {
    echo 'Exception when calling PeopleApi->people.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PeopleApi->new();
my $personId = 56; # Integer | Id of the person to delete

eval { 
    $api_instance->people.delete(personId => $personId);
};
if ($@) {
    warn "Exception when calling PeopleApi->people.delete: $@\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.PeopleApi()
personId = 56 # Integer | Id of the person to delete

try: 
    # Delete a person from the people list
    api_instance.people/delete(personId)
except ApiException as e:
    print("Exception when calling PeopleApi->people.delete: %s\n" % e)

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

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

public class PeopleApiExample {

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

import io.swagger.client.api.PeopleApi;

public class PeopleApiExample {

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

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

// Read the entire set of people, sorted by last name
[apiInstance people.readAllWithCompletionHandler: 
              ^(array[inline_response_200] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PeopleApi()

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

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

namespace Example
{
    public class people.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new PeopleApi();

            try
            {
                // Read the entire set of people, sorted by last name
                array[inline_response_200] result = apiInstance.people.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PeopleApi.people.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PeopleApi();

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

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

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

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

try: 
    # Read the entire set of people, sorted by last name
    api_response = api_instance.people/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PeopleApi->people.readAll: %s\n" % e)

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

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

public class PeopleApiExample {

    public static void main(String[] args) {
        
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id of the person to get
        try {
            inline_response_200 result = apiInstance.people.readOne(personId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PeopleApi;

public class PeopleApiExample {

    public static void main(String[] args) {
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id of the person to get
        try {
            inline_response_200 result = apiInstance.people.readOne(personId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.readOne");
            e.printStackTrace();
        }
    }
}

Integer *personId = 56; // Id of the person to get

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

// Read one person
[apiInstance people.readOneWith:personId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PeopleApi()

var personId = 56; // {Integer} Id of the person to get


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

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

namespace Example
{
    public class people.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new PeopleApi();
            var personId = 56;  // Integer | Id of the person to get

            try
            {
                // Read one person
                inline_response_200 result = apiInstance.people.readOne(personId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PeopleApi.people.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PeopleApi();
$personId = 56; // Integer | Id of the person to get

try {
    $result = $api_instance->people.readOne($personId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PeopleApi->people.readOne: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PeopleApi->new();
my $personId = 56; # Integer | Id of the person to get

eval { 
    my $result = $api_instance->people.readOne(personId => $personId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PeopleApi->people.readOne: $@\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.PeopleApi()
personId = 56 # Integer | Id of the person to get

try: 
    # Read one person
    api_response = api_instance.people/read_one(personId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PeopleApi->people.readOne: %s\n" % e)

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

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

public class PeopleApiExample {

    public static void main(String[] args) {
        
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id the person to update
        Person_1 person = ; // Person_1 | 
        try {
            Object result = apiInstance.people.update(personId, person);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PeopleApi;

public class PeopleApiExample {

    public static void main(String[] args) {
        PeopleApi apiInstance = new PeopleApi();
        Integer personId = 56; // Integer | Id the person to update
        Person_1 person = ; // Person_1 | 
        try {
            Object result = apiInstance.people.update(personId, person);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PeopleApi#people.update");
            e.printStackTrace();
        }
    }
}

Integer *personId = 56; // Id the person to update
Person_1 *person = ; //  (optional)

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

// Update a person
[apiInstance people.updateWith:personId
    person:person
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PeopleApi()

var personId = 56; // {Integer} Id the person to update

var opts = { 
  'person':  // {Person_1} 
};

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

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

namespace Example
{
    public class people.updateExample
    {
        public void main()
        {
            
            var apiInstance = new PeopleApi();
            var personId = 56;  // Integer | Id the person to update
            var person = new Person_1(); // Person_1 |  (optional) 

            try
            {
                // Update a person
                Object result = apiInstance.people.update(personId, person);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PeopleApi.people.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PeopleApi();
$personId = 56; // Integer | Id the person to update
$person = ; // Person_1 | 

try {
    $result = $api_instance->people.update($personId, $person);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PeopleApi->people.update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PeopleApi->new();
my $personId = 56; # Integer | Id the person to update
my $person = WWW::SwaggerClient::Object::Person_1->new(); # Person_1 | 

eval { 
    my $result = $api_instance->people.update(personId => $personId, person => $person);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PeopleApi->people.update: $@\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.PeopleApi()
personId = 56 # Integer | Id the person to update
person =  # Person_1 |  (optional)

try: 
    # Update a person
    api_response = api_instance.people/update(personId, person=person)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PeopleApi->people.update: %s\n" % e)

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

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

public class PhotosApiExample {

    public static void main(String[] args) {
        
        PhotosApi apiInstance = new PhotosApi();
        Photo photo = ; // Photo | photo to create
        try {
            Object result = apiInstance.photos.create(photo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PhotosApi;

public class PhotosApiExample {

    public static void main(String[] args) {
        PhotosApi apiInstance = new PhotosApi();
        Photo photo = ; // Photo | photo to create
        try {
            Object result = apiInstance.photos.create(photo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.create");
            e.printStackTrace();
        }
    }
}

Photo *photo = ; // photo to create

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

// Create a photo
[apiInstance photos.createWith:photo
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PhotosApi()

var photo = ; // {Photo} photo to create


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

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

namespace Example
{
    public class photos.createExample
    {
        public void main()
        {
            
            var apiInstance = new PhotosApi();
            var photo = new Photo(); // Photo | photo to create

            try
            {
                // Create a photo
                Object result = apiInstance.photos.create(photo);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhotosApi.photos.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PhotosApi();
$photo = ; // Photo | photo to create

try {
    $result = $api_instance->photos.create($photo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PhotosApi->photos.create: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PhotosApi->new();
my $photo = WWW::SwaggerClient::Object::Photo->new(); # Photo | photo to create

eval { 
    my $result = $api_instance->photos.create(photo => $photo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PhotosApi->photos.create: $@\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.PhotosApi()
photo =  # Photo | photo to create

try: 
    # Create a photo
    api_response = api_instance.photos/create(photo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PhotosApi->photos.create: %s\n" % e)

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

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

public class PhotosApiExample {

    public static void main(String[] args) {
        
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id of the photo to delete
        try {
            apiInstance.photos.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PhotosApi;

public class PhotosApiExample {

    public static void main(String[] args) {
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id of the photo to delete
        try {
            apiInstance.photos.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.delete");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the photo to delete

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

// Delete a photo from the photos list
[apiInstance photos.deleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PhotosApi()

var id = id_example; // {String} id of the photo to delete


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

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

namespace Example
{
    public class photos.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new PhotosApi();
            var id = id_example;  // String | id of the photo to delete

            try
            {
                // Delete a photo from the photos list
                apiInstance.photos.delete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhotosApi.photos.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PhotosApi();
$id = id_example; // String | id of the photo to delete

try {
    $api_instance->photos.delete($id);
} catch (Exception $e) {
    echo 'Exception when calling PhotosApi->photos.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PhotosApi->new();
my $id = id_example; # String | id of the photo to delete

eval { 
    $api_instance->photos.delete(id => $id);
};
if ($@) {
    warn "Exception when calling PhotosApi->photos.delete: $@\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.PhotosApi()
id = id_example # String | id of the photo to delete

try: 
    # Delete a photo from the photos list
    api_instance.photos/delete(id)
except ApiException as e:
    print("Exception when calling PhotosApi->photos.delete: %s\n" % e)

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

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

public class PhotosApiExample {

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

import io.swagger.client.api.PhotosApi;

public class PhotosApiExample {

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

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

// Read the entire set of photos, sorted by sample_id
[apiInstance photos.readAllWithCompletionHandler: 
              ^(array[inline_response_200_6] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PhotosApi()

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

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

namespace Example
{
    public class photos.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new PhotosApi();

            try
            {
                // Read the entire set of photos, sorted by sample_id
                array[inline_response_200_6] result = apiInstance.photos.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhotosApi.photos.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PhotosApi();

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

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

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

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

try: 
    # Read the entire set of photos, sorted by sample_id
    api_response = api_instance.photos/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PhotosApi->photos.readAll: %s\n" % e)

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

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

public class PhotosApiExample {

    public static void main(String[] args) {
        
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id of the photo to get
        try {
            photo result = apiInstance.photos.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PhotosApi;

public class PhotosApiExample {

    public static void main(String[] args) {
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id of the photo to get
        try {
            photo result = apiInstance.photos.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.readOne");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the photo to get

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

// Read one photo
[apiInstance photos.readOneWith:id
              completionHandler: ^(photo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PhotosApi()

var id = id_example; // {String} id of the photo to get


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

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

namespace Example
{
    public class photos.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new PhotosApi();
            var id = id_example;  // String | id of the photo to get

            try
            {
                // Read one photo
                photo result = apiInstance.photos.readOne(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhotosApi.photos.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PhotosApi();
$id = id_example; // String | id of the photo to get

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

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

my $api_instance = WWW::SwaggerClient::PhotosApi->new();
my $id = id_example; # String | id of the photo to get

eval { 
    my $result = $api_instance->photos.readOne(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PhotosApi->photos.readOne: $@\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.PhotosApi()
id = id_example # String | id of the photo to get

try: 
    # Read one photo
    api_response = api_instance.photos/read_one(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PhotosApi->photos.readOne: %s\n" % e)

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

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

public class PhotosApiExample {

    public static void main(String[] args) {
        
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id the photo to update
        Photo_1 photo = ; // Photo_1 | 
        try {
            Object result = apiInstance.photos.update(id, photo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PhotosApi;

public class PhotosApiExample {

    public static void main(String[] args) {
        PhotosApi apiInstance = new PhotosApi();
        String id = id_example; // String | id the photo to update
        Photo_1 photo = ; // Photo_1 | 
        try {
            Object result = apiInstance.photos.update(id, photo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PhotosApi#photos.update");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id the photo to update
Photo_1 *photo = ; //  (optional)

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

// update a photo
[apiInstance photos.updateWith:id
    photo:photo
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.PhotosApi()

var id = id_example; // {String} id the photo to update

var opts = { 
  'photo':  // {Photo_1} 
};

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

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

namespace Example
{
    public class photos.updateExample
    {
        public void main()
        {
            
            var apiInstance = new PhotosApi();
            var id = id_example;  // String | id the photo to update
            var photo = new Photo_1(); // Photo_1 |  (optional) 

            try
            {
                // update a photo
                Object result = apiInstance.photos.update(id, photo);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PhotosApi.photos.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\PhotosApi();
$id = id_example; // String | id the photo to update
$photo = ; // Photo_1 | 

try {
    $result = $api_instance->photos.update($id, $photo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PhotosApi->photos.update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PhotosApi->new();
my $id = id_example; # String | id the photo to update
my $photo = WWW::SwaggerClient::Object::Photo_1->new(); # Photo_1 | 

eval { 
    my $result = $api_instance->photos.update(id => $id, photo => $photo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PhotosApi->photos.update: $@\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.PhotosApi()
id = id_example # String | id the photo to update
photo =  # Photo_1 |  (optional)

try: 
    # update a photo
    api_response = api_instance.photos/update(id, photo=photo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PhotosApi->photos.update: %s\n" % e)

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

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

public class SamplesApiExample {

    public static void main(String[] args) {
        
        SamplesApi apiInstance = new SamplesApi();
        Sample sample = ; // Sample | sample to create
        try {
            Object result = apiInstance.samples.create(sample);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamplesApi;

public class SamplesApiExample {

    public static void main(String[] args) {
        SamplesApi apiInstance = new SamplesApi();
        Sample sample = ; // Sample | sample to create
        try {
            Object result = apiInstance.samples.create(sample);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.create");
            e.printStackTrace();
        }
    }
}

Sample *sample = ; // sample to create

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

// Create a sample
[apiInstance samples.createWith:sample
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.SamplesApi()

var sample = ; // {Sample} sample to create


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

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

namespace Example
{
    public class samples.createExample
    {
        public void main()
        {
            
            var apiInstance = new SamplesApi();
            var sample = new Sample(); // Sample | sample to create

            try
            {
                // Create a sample
                Object result = apiInstance.samples.create(sample);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamplesApi.samples.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SamplesApi();
$sample = ; // Sample | sample to create

try {
    $result = $api_instance->samples.create($sample);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SamplesApi->samples.create: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::SamplesApi->new();
my $sample = WWW::SwaggerClient::Object::Sample->new(); # Sample | sample to create

eval { 
    my $result = $api_instance->samples.create(sample => $sample);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SamplesApi->samples.create: $@\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.SamplesApi()
sample =  # Sample | sample to create

try: 
    # Create a sample
    api_response = api_instance.samples/create(sample)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamplesApi->samples.create: %s\n" % e)

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

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

public class SamplesApiExample {

    public static void main(String[] args) {
        
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id of the sample to delete
        try {
            apiInstance.samples.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamplesApi;

public class SamplesApiExample {

    public static void main(String[] args) {
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id of the sample to delete
        try {
            apiInstance.samples.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.delete");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the sample to delete

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

// Delete a sample from the samples list
[apiInstance samples.deleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.SamplesApi()

var id = id_example; // {String} id of the sample to delete


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

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

namespace Example
{
    public class samples.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new SamplesApi();
            var id = id_example;  // String | id of the sample to delete

            try
            {
                // Delete a sample from the samples list
                apiInstance.samples.delete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamplesApi.samples.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SamplesApi();
$id = id_example; // String | id of the sample to delete

try {
    $api_instance->samples.delete($id);
} catch (Exception $e) {
    echo 'Exception when calling SamplesApi->samples.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::SamplesApi->new();
my $id = id_example; # String | id of the sample to delete

eval { 
    $api_instance->samples.delete(id => $id);
};
if ($@) {
    warn "Exception when calling SamplesApi->samples.delete: $@\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.SamplesApi()
id = id_example # String | id of the sample to delete

try: 
    # Delete a sample from the samples list
    api_instance.samples/delete(id)
except ApiException as e:
    print("Exception when calling SamplesApi->samples.delete: %s\n" % e)

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

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

public class SamplesApiExample {

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

import io.swagger.client.api.SamplesApi;

public class SamplesApiExample {

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

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

// Read the entire set of samples, sorted by isbn
[apiInstance samples.readAllWithCompletionHandler: 
              ^(array[inline_response_200_4] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.SamplesApi()

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

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

namespace Example
{
    public class samples.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new SamplesApi();

            try
            {
                // Read the entire set of samples, sorted by isbn
                array[inline_response_200_4] result = apiInstance.samples.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamplesApi.samples.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SamplesApi();

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

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

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

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

try: 
    # Read the entire set of samples, sorted by isbn
    api_response = api_instance.samples/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamplesApi->samples.readAll: %s\n" % e)

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

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

public class SamplesApiExample {

    public static void main(String[] args) {
        
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id of the sample to get
        try {
            sample result = apiInstance.samples.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamplesApi;

public class SamplesApiExample {

    public static void main(String[] args) {
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id of the sample to get
        try {
            sample result = apiInstance.samples.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.readOne");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id of the sample to get

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

// Read one sample
[apiInstance samples.readOneWith:id
              completionHandler: ^(sample output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.SamplesApi()

var id = id_example; // {String} id of the sample to get


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

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

namespace Example
{
    public class samples.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new SamplesApi();
            var id = id_example;  // String | id of the sample to get

            try
            {
                // Read one sample
                sample result = apiInstance.samples.readOne(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamplesApi.samples.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SamplesApi();
$id = id_example; // String | id of the sample to get

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

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

my $api_instance = WWW::SwaggerClient::SamplesApi->new();
my $id = id_example; # String | id of the sample to get

eval { 
    my $result = $api_instance->samples.readOne(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SamplesApi->samples.readOne: $@\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.SamplesApi()
id = id_example # String | id of the sample to get

try: 
    # Read one sample
    api_response = api_instance.samples/read_one(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamplesApi->samples.readOne: %s\n" % e)

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

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

public class SamplesApiExample {

    public static void main(String[] args) {
        
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id the sample to update
        Sample_1 sample = ; // Sample_1 | 
        try {
            Object result = apiInstance.samples.update(id, sample);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamplesApi;

public class SamplesApiExample {

    public static void main(String[] args) {
        SamplesApi apiInstance = new SamplesApi();
        String id = id_example; // String | id the sample to update
        Sample_1 sample = ; // Sample_1 | 
        try {
            Object result = apiInstance.samples.update(id, sample);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamplesApi#samples.update");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // id the sample to update
Sample_1 *sample = ; //  (optional)

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

// Update a sample
[apiInstance samples.updateWith:id
    sample:sample
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.SamplesApi()

var id = id_example; // {String} id the sample to update

var opts = { 
  'sample':  // {Sample_1} 
};

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

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

namespace Example
{
    public class samples.updateExample
    {
        public void main()
        {
            
            var apiInstance = new SamplesApi();
            var id = id_example;  // String | id the sample to update
            var sample = new Sample_1(); // Sample_1 |  (optional) 

            try
            {
                // Update a sample
                Object result = apiInstance.samples.update(id, sample);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamplesApi.samples.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\SamplesApi();
$id = id_example; // String | id the sample to update
$sample = ; // Sample_1 | 

try {
    $result = $api_instance->samples.update($id, $sample);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SamplesApi->samples.update: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::SamplesApi->new();
my $id = id_example; # String | id the sample to update
my $sample = WWW::SwaggerClient::Object::Sample_1->new(); # Sample_1 | 

eval { 
    my $result = $api_instance->samples.update(id => $id, sample => $sample);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SamplesApi->samples.update: $@\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.SamplesApi()
id = id_example # String | id the sample to update
sample =  # Sample_1 |  (optional)

try: 
    # Update a sample
    api_response = api_instance.samples/update(id, sample=sample)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamplesApi->samples.update: %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 user = ; // User | user to create
        try {
            Object result = apiInstance.users.create(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        User user = ; // User | user to create
        try {
            Object result = apiInstance.users.create(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.create");
            e.printStackTrace();
        }
    }
}

User *user = ; // user to create

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

// Create a user
[apiInstance users.createWith:user
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.UsersApi()

var user = ; // {User} user to create


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

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

namespace Example
{
    public class users.createExample
    {
        public void main()
        {
            
            var apiInstance = new UsersApi();
            var user = new User(); // User | user to create

            try
            {
                // Create a user
                Object result = apiInstance.users.create(user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.users.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UsersApi();
$user = ; // User | user to create

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $user = WWW::SwaggerClient::Object::User->new(); # User | user to create

eval { 
    my $result = $api_instance->users.create(user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->users.create: $@\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()
user =  # User | user to create

try: 
    # Create a user
    api_response = api_instance.users/create(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->users.create: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id of the user to delete
        try {
            apiInstance.users.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.delete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id of the user to delete
        try {
            apiInstance.users.delete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.delete");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // Id of the user to delete

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

// Delete a user from the users list
[apiInstance users.deleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.UsersApi()

var id = id_example; // {String} Id of the user to delete


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

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

namespace Example
{
    public class users.deleteExample
    {
        public void main()
        {
            
            var apiInstance = new UsersApi();
            var id = id_example;  // String | Id of the user to delete

            try
            {
                // Delete a user from the users list
                apiInstance.users.delete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.users.delete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = id_example; // String | Id of the user to delete

try {
    $api_instance->users.delete($id);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->users.delete: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = id_example; # String | Id of the user to delete

eval { 
    $api_instance->users.delete(id => $id);
};
if ($@) {
    warn "Exception when calling UsersApi->users.delete: $@\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 = id_example # String | Id of the user to delete

try: 
    # Delete a user from the users list
    api_instance.users/delete(id)
except ApiException as e:
    print("Exception when calling UsersApi->users.delete: %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[inline_response_200_1] result = apiInstance.users.readAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.readAll");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

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

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

// Read the entire set of users, sorted by username
[apiInstance users.readAllWithCompletionHandler: 
              ^(array[inline_response_200_1] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.UsersApi()

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

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

namespace Example
{
    public class users.readAllExample
    {
        public void main()
        {
            
            var apiInstance = new UsersApi();

            try
            {
                // Read the entire set of users, sorted by username
                array[inline_response_200_1] result = apiInstance.users.readAll();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.users.readAll: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UsersApi();

try {
    $result = $api_instance->users.readAll();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->users.readAll: ', $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->users.readAll();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->users.readAll: $@\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: 
    # Read the entire set of users, sorted by username
    api_response = api_instance.users/read_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->users.readAll: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id of the user to get
        try {
            inline_response_200_2 result = apiInstance.users.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.readOne");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id of the user to get
        try {
            inline_response_200_2 result = apiInstance.users.readOne(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.readOne");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // Id of the user to get

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

// Read one user
[apiInstance users.readOneWith:id
              completionHandler: ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.UsersApi()

var id = id_example; // {String} Id of the user to get


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

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

namespace Example
{
    public class users.readOneExample
    {
        public void main()
        {
            
            var apiInstance = new UsersApi();
            var id = id_example;  // String | Id of the user to get

            try
            {
                // Read one user
                inline_response_200_2 result = apiInstance.users.readOne(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.users.readOne: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = id_example; // String | Id of the user to get

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = id_example; # String | Id of the user to get

eval { 
    my $result = $api_instance->users.readOne(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->users.readOne: $@\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 = id_example # String | Id of the user to get

try: 
    # Read one user
    api_response = api_instance.users/read_one(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->users.readOne: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id the user to update
        User_1 user = ; // User_1 | 
        try {
            Object result = apiInstance.users.update(id, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String id = id_example; // String | Id the user to update
        User_1 user = ; // User_1 | 
        try {
            Object result = apiInstance.users.update(id, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#users.update");
            e.printStackTrace();
        }
    }
}

String *id = id_example; // Id the user to update
User_1 *user = ; //  (optional)

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

// Update a user
[apiInstance users.updateWith:id
    user:user
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerRestArticle = require('swagger_rest_article');

var api = new SwaggerRestArticle.UsersApi()

var id = id_example; // {String} Id the user to update

var opts = { 
  'user':  // {User_1} 
};

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

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

namespace Example
{
    public class users.updateExample
    {
        public void main()
        {
            
            var apiInstance = new UsersApi();
            var id = id_example;  // String | Id the user to update
            var user = new User_1(); // User_1 |  (optional) 

            try
            {
                // Update a user
                Object result = apiInstance.users.update(id, user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.users.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\UsersApi();
$id = id_example; // String | Id the user to update
$user = ; // User_1 | 

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

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

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $id = id_example; # String | Id the user to update
my $user = WWW::SwaggerClient::Object::User_1->new(); # User_1 | 

eval { 
    my $result = $api_instance->users.update(id => $id, user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->users.update: $@\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 = id_example # String | Id the user to update
user =  # User_1 |  (optional)

try: 
    # Update a user
    api_response = api_instance.users/update(id, user=user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->users.update: %s\n" % e)