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

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

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

        // Create an instance of the API class
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 
        Comment comment = ; // Comment | 

        try {
            Comment result = apiInstance.editComment(id, comment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#editComment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 
        Comment comment = ; // Comment | 

        try {
            Comment result = apiInstance.editComment(id, comment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#editComment");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CommentRestControllerApi *apiInstance = [[CommentRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Comment *comment = ; // 

[apiInstance editCommentWith:id
    comment:comment
              completionHandler: ^(Comment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CommentRestControllerApi()
var id = 789; // {Long} 
var comment = ; // {Comment} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CommentRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var comment = new Comment(); // Comment | 

            try {
                Comment result = apiInstance.editComment(id, comment);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.editComment: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CommentRestControllerApi();
$id = 789; // Long | 
$comment = ; // Comment | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CommentRestControllerApi->new();
my $id = 789; # Long | 
my $comment = WWW::OPenAPIClient::Object::Comment->new(); # Comment | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CommentRestControllerApi()
id = 789 # Long |  (default to null)
comment =  # Comment | 

try:
    api_response = api_instance.edit_comment(id, comment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->editComment: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let comment = ; // Comment

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.editComment(id, comment, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 

        try {
            Comment result = apiInstance.getComment(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getComment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 

        try {
            Comment result = apiInstance.getComment(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getComment");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CommentRestControllerApi *apiInstance = [[CommentRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getCommentWith:id
              completionHandler: ^(Comment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CommentRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CommentRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Comment result = apiInstance.getComment(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getComment: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CommentRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CommentRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CommentRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_comment(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getComment: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.getComment(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 

        try {
            Comment result = apiInstance.removeComment(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#removeComment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 

        try {
            Comment result = apiInstance.removeComment(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#removeComment");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CommentRestControllerApi *apiInstance = [[CommentRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance removeCommentWith:id
              completionHandler: ^(Comment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CommentRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CommentRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Comment result = apiInstance.removeComment(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.removeComment: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CommentRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CommentRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.CommentRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.remove_comment(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->removeComment: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.removeComment(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Comment comment = ; // Comment | 

        try {
            Comment result = apiInstance.addComment(id, comment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#addComment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Comment comment = ; // Comment | 

        try {
            Comment result = apiInstance.addComment(id, comment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#addComment");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Comment *comment = ; // 

[apiInstance addCommentWith:id
    comment:comment
              completionHandler: ^(Comment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 
var comment = ; // {Comment} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var comment = new Comment(); // Comment | 

            try {
                Comment result = apiInstance.addComment(id, comment);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.addComment: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 
$comment = ; // Comment | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 
my $comment = WWW::OPenAPIClient::Object::Comment->new(); # Comment | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)
comment =  # Comment | 

try:
    api_response = api_instance.add_comment(id, comment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->addComment: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let comment = ; // Comment

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.addComment(id, comment, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Film film = ; // Film | 

        try {
            Film result = apiInstance.addFilm(film);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#addFilm");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Film film = ; // Film | 

        try {
            Film result = apiInstance.addFilm(film);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#addFilm");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Film *film = ; // 

[apiInstance addFilmWith:film
              completionHandler: ^(Film output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var film = ; // {Film} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var film = new Film(); // Film | 

            try {
                Film result = apiInstance.addFilm(film);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.addFilm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$film = ; // Film | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $film = WWW::OPenAPIClient::Object::Film->new(); # Film | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
film =  # Film | 

try:
    api_response = api_instance.add_film(film)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->addFilm: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let film = ; // Film

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.addFilm(film, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();

        try {
            array['Integer'] result = apiInstance.calculateChart();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#calculateChart");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();

        try {
            array['Integer'] result = apiInstance.calculateChart();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#calculateChart");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];

[apiInstance calculateChartWithCompletionHandler: 
              ^(array['Integer'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.calculateChart(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();

            try {
                array['Integer'] result = apiInstance.calculateChart();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.calculateChart: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()

try:
    api_response = api_instance.calculate_chart()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->calculateChart: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.calculateChart(&context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.downloadImage1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#downloadImage1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.downloadImage1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#downloadImage1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance downloadImage1With:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Object result = apiInstance.downloadImage1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.downloadImage1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.download_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->downloadImage1: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.downloadImage1(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Film film = ; // Film | 

        try {
            Film result = apiInstance.editFilm(id, film);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#editFilm");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Film film = ; // Film | 

        try {
            Film result = apiInstance.editFilm(id, film);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#editFilm");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Film *film = ; // 

[apiInstance editFilmWith:id
    film:film
              completionHandler: ^(Film output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 
var film = ; // {Film} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var film = new Film(); // Film | 

            try {
                Film result = apiInstance.editFilm(id, film);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.editFilm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 
$film = ; // Film | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 
my $film = WWW::OPenAPIClient::Object::Film->new(); # Film | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)
film =  # Film | 

try:
    api_response = api_instance.edit_film(id, film)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->editFilm: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let film = ; // Film

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.editFilm(id, film, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

        try {
            Object result = apiInstance.editImage1(id, inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#editImage1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

        try {
            Object result = apiInstance.editImage1(id, inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#editImage1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
InlineObject1 *inlineObject1 = ; //  (optional)

[apiInstance editImage1With:id
    inlineObject1:inlineObject1
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject1':  // {InlineObject1} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var inlineObject1 = new InlineObject1(); // InlineObject1 |  (optional) 

            try {
                Object result = apiInstance.editImage1(id, inlineObject1);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.editImage1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 
$inlineObject1 = ; // InlineObject1 | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 
my $inlineObject1 = WWW::OPenAPIClient::Object::InlineObject1->new(); # InlineObject1 | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)
inlineObject1 =  # InlineObject1 |  (optional)

try:
    api_response = api_instance.edit_image1(id, inlineObject1=inlineObject1)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->editImage1: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let inlineObject1 = ; // InlineObject1

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.editImage1(id, inlineObject1, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            FilmComments result = apiInstance.getFilm(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#getFilm");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            FilmComments result = apiInstance.getFilm(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#getFilm");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getFilmWith:id
              completionHandler: ^(FilmComments output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                FilmComments result = apiInstance.getFilm(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.getFilm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_film(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->getFilm: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.getFilm(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();

        try {
            FilmsList result = apiInstance.getMenu();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#getMenu");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();

        try {
            FilmsList result = apiInstance.getMenu();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#getMenu");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];

[apiInstance getMenuWithCompletionHandler: 
              ^(FilmsList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMenu(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();

            try {
                FilmsList result = apiInstance.getMenu();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.getMenu: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()

try:
    api_response = api_instance.get_menu()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->getMenu: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.getMenu(&context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageComment result = apiInstance.moreComments1(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreComments1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageComment result = apiInstance.moreComments1(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreComments1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Integer *page = 56; //  (default to null)

[apiInstance moreComments1With:id
    page:page
              completionHandler: ^(PageComment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 
var page = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var page = 56;  // Integer |  (default to null)

            try {
                PageComment result = apiInstance.moreComments1(id, page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.moreComments1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 
$page = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 
my $page = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)
page = 56 # Integer |  (default to null)

try:
    api_response = api_instance.more_comments1(id, page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->moreComments1: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let page = 56; // Integer

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.moreComments1(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Integer page = 56; // Integer | 
        String genre = genre_example; // String | 
        String name = name_example; // String | 

        try {
            PageFilm result = apiInstance.moreFilms(page, genre, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreFilms");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Integer page = 56; // Integer | 
        String genre = genre_example; // String | 
        String name = name_example; // String | 

        try {
            PageFilm result = apiInstance.moreFilms(page, genre, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreFilms");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Integer *page = 56; //  (default to null)
String *genre = genre_example; //  (optional) (default to null)
String *name = name_example; //  (optional) (default to null)

[apiInstance moreFilmsWith:page
    genre:genre
    name:name
              completionHandler: ^(PageFilm output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var page = 56; // {Integer} 
var opts = {
  'genre': genre_example, // {String} 
  'name': name_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var page = 56;  // Integer |  (default to null)
            var genre = genre_example;  // String |  (optional)  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)

            try {
                PageFilm result = apiInstance.moreFilms(page, genre, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.moreFilms: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$page = 56; // Integer | 
$genre = genre_example; // String | 
$name = name_example; // String | 

try {
    $result = $api_instance->moreFilms($page, $genre, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FilmRestControllerApi->moreFilms: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $page = 56; # Integer | 
my $genre = genre_example; # String | 
my $name = name_example; # String | 

eval {
    my $result = $api_instance->moreFilms(page => $page, genre => $genre, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FilmRestControllerApi->moreFilms: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
page = 56 # Integer |  (default to null)
genre = genre_example # String |  (optional) (default to null)
name = name_example # String |  (optional) (default to null)

try:
    api_response = api_instance.more_films(page, genre=genre, name=name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->moreFilms: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let genre = genre_example; // String
    let name = name_example; // String

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.moreFilms(page, genre, name, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            PageRecommendation result = apiInstance.moreRecommendations(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreRecommendations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            PageRecommendation result = apiInstance.moreRecommendations(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#moreRecommendations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Integer *page = 56; //  (default to null)

[apiInstance moreRecommendationsWith:page
              completionHandler: ^(PageRecommendation output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var page = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var page = 56;  // Integer |  (default to null)

            try {
                PageRecommendation result = apiInstance.moreRecommendations(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.moreRecommendations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$page = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $page = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
page = 56 # Integer |  (default to null)

try:
    api_response = api_instance.more_recommendations(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->moreRecommendations: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.moreRecommendations(page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            Film result = apiInstance.removeFilm(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#removeFilm");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 

        try {
            Film result = apiInstance.removeFilm(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#removeFilm");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance removeFilmWith:id
              completionHandler: ^(Film output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Film result = apiInstance.removeFilm(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.removeFilm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.remove_film(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->removeFilm: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.removeFilm(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        InlineObject2 inlineObject2 = ; // InlineObject2 | 

        try {
            Object result = apiInstance.uploadImage(id, inlineObject2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#uploadImage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.FilmRestControllerApi;

public class FilmRestControllerApiExample {
    public static void main(String[] args) {
        FilmRestControllerApi apiInstance = new FilmRestControllerApi();
        Long id = 789; // Long | 
        InlineObject2 inlineObject2 = ; // InlineObject2 | 

        try {
            Object result = apiInstance.uploadImage(id, inlineObject2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FilmRestControllerApi#uploadImage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FilmRestControllerApi *apiInstance = [[FilmRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
InlineObject2 *inlineObject2 = ; //  (optional)

[apiInstance uploadImageWith:id
    inlineObject2:inlineObject2
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.FilmRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject2':  // {InlineObject2} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FilmRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var inlineObject2 = new InlineObject2(); // InlineObject2 |  (optional) 

            try {
                Object result = apiInstance.uploadImage(id, inlineObject2);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FilmRestControllerApi.uploadImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FilmRestControllerApi();
$id = 789; // Long | 
$inlineObject2 = ; // InlineObject2 | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FilmRestControllerApi->new();
my $id = 789; # Long | 
my $inlineObject2 = WWW::OPenAPIClient::Object::InlineObject2->new(); # InlineObject2 | 

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

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

# Create an instance of the API class
api_instance = openapi_client.FilmRestControllerApi()
id = 789 # Long |  (default to null)
inlineObject2 =  # InlineObject2 |  (optional)

try:
    api_response = api_instance.upload_image(id, inlineObject2=inlineObject2)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FilmRestControllerApi->uploadImage: %s\n" % e)

extern crate FilmRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let inlineObject2 = ; // InlineObject2

    let mut context = FilmRestControllerApi::Context::default();
    let result = client.uploadImage(id, inlineObject2, &context).wait();

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];

[apiInstance logOutWithCompletionHandler: 
              ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();

            try {
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.logOut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()

try:
    api_response = api_instance.log_out()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->logOut: %s\n" % e)

extern crate LoginRestControllerApi;

pub fn main() {

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.logOut(&context).wait();

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];
LoginRequest *loginRequest = ; // 
String *accessToken = accessToken_example; //  (optional) (default to null)
String *refreshToken = refreshToken_example; //  (optional) (default to null)

[apiInstance loginWith:loginRequest
    accessToken:accessToken
    refreshToken:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();
$loginRequest = ; // LoginRequest | 
$accessToken = accessToken_example; // String | 
$refreshToken = refreshToken_example; // String | 

try {
    $result = $api_instance->login($loginRequest, $accessToken, $refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginRestControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 
my $accessToken = accessToken_example; # String | 
my $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest, accessToken => $accessToken, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->login: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
loginRequest =  # LoginRequest | 
accessToken = accessToken_example # String |  (optional) (default to null)
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    api_response = api_instance.login(loginRequest, accessToken=accessToken, refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->login: %s\n" % e)

extern crate LoginRestControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest
    let accessToken = accessToken_example; // String
    let refreshToken = refreshToken_example; // String

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.login(loginRequest, accessToken, refreshToken, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.downloadImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#downloadImage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.downloadImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#downloadImage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance downloadImageWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Object result = apiInstance.downloadImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.downloadImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.download_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->downloadImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.downloadImage(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        InlineObject inlineObject = ; // InlineObject | 

        try {
            Object result = apiInstance.editImage(id, inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editImage");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        InlineObject inlineObject = ; // InlineObject | 

        try {
            Object result = apiInstance.editImage(id, inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editImage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
InlineObject *inlineObject = ; //  (optional)

[apiInstance editImageWith:id
    inlineObject:inlineObject
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject':  // {InlineObject} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var inlineObject = new InlineObject(); // InlineObject |  (optional) 

            try {
                Object result = apiInstance.editImage(id, inlineObject);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$inlineObject = ; // InlineObject | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
inlineObject =  # InlineObject |  (optional)

try:
    api_response = api_instance.edit_image(id, inlineObject=inlineObject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->editImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let inlineObject = ; // InlineObject

    let mut context = UserRestControllerApi::Context::default();
    let result = client.editImage(id, inlineObject, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        String oldPassword = oldPassword_example; // String | 
        String newPassword = newPassword_example; // String | 

        try {
            User result = apiInstance.editPassword(id, oldPassword, newPassword);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editPassword");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        String oldPassword = oldPassword_example; // String | 
        String newPassword = newPassword_example; // String | 

        try {
            User result = apiInstance.editPassword(id, oldPassword, newPassword);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editPassword");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
String *oldPassword = oldPassword_example; //  (default to null)
String *newPassword = newPassword_example; //  (default to null)

[apiInstance editPasswordWith:id
    oldPassword:oldPassword
    newPassword:newPassword
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var oldPassword = oldPassword_example; // {String} 
var newPassword = newPassword_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var oldPassword = oldPassword_example;  // String |  (default to null)
            var newPassword = newPassword_example;  // String |  (default to null)

            try {
                User result = apiInstance.editPassword(id, oldPassword, newPassword);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editPassword: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$oldPassword = oldPassword_example; // String | 
$newPassword = newPassword_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $oldPassword = oldPassword_example; # String | 
my $newPassword = newPassword_example; # String | 

eval {
    my $result = $api_instance->editPassword(id => $id, oldPassword => $oldPassword, newPassword => $newPassword);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->editPassword: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
oldPassword = oldPassword_example # String |  (default to null)
newPassword = newPassword_example # String |  (default to null)

try:
    api_response = api_instance.edit_password(id, oldPassword, newPassword)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->editPassword: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let oldPassword = oldPassword_example; // String
    let newPassword = newPassword_example; // String

    let mut context = UserRestControllerApi::Context::default();
    let result = client.editPassword(id, oldPassword, newPassword, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        String newEmail = newEmail_example; // String | 

        try {
            User result = apiInstance.editProfile(id, newEmail);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        String newEmail = newEmail_example; // String | 

        try {
            User result = apiInstance.editProfile(id, newEmail);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
String *newEmail = newEmail_example; //  (default to null)

[apiInstance editProfileWith:id
    newEmail:newEmail
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var newEmail = newEmail_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var newEmail = newEmail_example;  // String |  (default to null)

            try {
                User result = apiInstance.editProfile(id, newEmail);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$newEmail = newEmail_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $newEmail = newEmail_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
newEmail = newEmail_example # String |  (default to null)

try:
    api_response = api_instance.edit_profile(id, newEmail)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->editProfile: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let newEmail = newEmail_example; // String

    let mut context = UserRestControllerApi::Context::default();
    let result = client.editProfile(id, newEmail, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            User result = apiInstance.followUnfollow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#followUnfollow");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            User result = apiInstance.followUnfollow(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#followUnfollow");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance followUnfollowWith:id
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                User result = apiInstance.followUnfollow(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.followUnfollow: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.follow_unfollow(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->followUnfollow: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.followUnfollow(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageUser result = apiInstance.followers(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#followers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageUser result = apiInstance.followers(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#followers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Integer *page = 56; //  (default to null)

[apiInstance followersWith:id
    page:page
              completionHandler: ^(PageUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var page = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var page = 56;  // Integer |  (default to null)

            try {
                PageUser result = apiInstance.followers(id, page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.followers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$page = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $page = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
page = 56 # Integer |  (default to null)

try:
    api_response = api_instance.followers(id, page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->followers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let page = 56; // Integer

    let mut context = UserRestControllerApi::Context::default();
    let result = client.followers(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageUser result = apiInstance.following(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#following");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageUser result = apiInstance.following(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#following");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Integer *page = 56; //  (default to null)

[apiInstance followingWith:id
    page:page
              completionHandler: ^(PageUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var page = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var page = 56;  // Integer |  (default to null)

            try {
                PageUser result = apiInstance.following(id, page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.following: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$page = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $page = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
page = 56 # Integer |  (default to null)

try:
    api_response = api_instance.following(id, page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->following: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let page = 56; // Integer

    let mut context = UserRestControllerApi::Context::default();
    let result = client.following(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserComments result = apiInstance.getProfile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserComments result = apiInstance.getProfile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getProfileWith:id
              completionHandler: ^(UserComments output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                UserComments result = apiInstance.getProfile(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_profile(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getProfile: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getProfile(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            UserComments result = apiInstance.me();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#me");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            UserComments result = apiInstance.me();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#me");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];

[apiInstance meWithCompletionHandler: 
              ^(UserComments output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.me(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();

            try {
                UserComments result = apiInstance.me();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.me: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()

try:
    api_response = api_instance.me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->me: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.me(&context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageComment result = apiInstance.moreComments(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#moreComments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        Integer page = 56; // Integer | 

        try {
            PageComment result = apiInstance.moreComments(id, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#moreComments");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
Integer *page = 56; //  (default to null)

[apiInstance moreCommentsWith:id
    page:page
              completionHandler: ^(PageComment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var page = 56; // {Integer} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var page = 56;  // Integer |  (default to null)

            try {
                PageComment result = apiInstance.moreComments(id, page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.moreComments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$page = 56; // Integer | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $page = 56; # Integer | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
page = 56 # Integer |  (default to null)

try:
    api_response = api_instance.more_comments(id, page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->moreComments: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let page = 56; // Integer

    let mut context = UserRestControllerApi::Context::default();
    let result = client.moreComments(id, page, &context).wait();

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

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

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

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

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String name = name_example; // String | 
        String email = email_example; // String | 
        String password = password_example; // String | 

        try {
            User result = apiInstance.register(name, email, password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#register");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String name = name_example; // String | 
        String email = email_example; // String | 
        String password = password_example; // String | 

        try {
            User result = apiInstance.register(name, email, password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#register");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
String *name = name_example; //  (default to null)
String *email = email_example; //  (default to null)
String *password = password_example; //  (default to null)

[apiInstance registerWith:name
    email:email
    password:password
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var name = name_example; // {String} 
var email = email_example; // {String} 
var password = password_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var name = name_example;  // String |  (default to null)
            var email = email_example;  // String |  (default to null)
            var password = password_example;  // String |  (default to null)

            try {
                User result = apiInstance.register(name, email, password);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.register: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$name = name_example; // String | 
$email = email_example; // String | 
$password = password_example; // String | 

try {
    $result = $api_instance->register($name, $email, $password);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->register: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $name = name_example; # String | 
my $email = email_example; # String | 
my $password = password_example; # String | 

eval {
    my $result = $api_instance->register(name => $name, email => $email, password => $password);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->register: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
name = name_example # String |  (default to null)
email = email_example # String |  (default to null)
password = password_example # String |  (default to null)

try:
    api_response = api_instance.register(name, email, password)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->register: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let name = name_example; // String
    let email = email_example; // String
    let password = password_example; // String

    let mut context = UserRestControllerApi::Context::default();
    let result = client.register(name, email, password, &context).wait();

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