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 {
            Object result = apiInstance.deleteComment(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#deleteComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteComment(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteComment: $e\n');
}

import org.openapitools.client.api.CommentRestControllerApi;

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

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

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

[apiInstance deleteCommentWith: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.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.deleteComment(id, callback);

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

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

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

            try {
                Object result = apiInstance.deleteComment(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.deleteComment: " + 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->deleteComment($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommentRestControllerApi->deleteComment: ', $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->deleteComment(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommentRestControllerApi->deleteComment: $@\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.delete_comment(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->deleteComment: %s\n" % e)

extern crate CommentRestControllerApi;

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

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.deleteComment(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 {
            CommentDTO result = apiInstance.getCommentById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getCommentById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getCommentById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getCommentById: $e\n');
}

import org.openapitools.client.api.CommentRestControllerApi;

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

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

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

[apiInstance getCommentByIdWith:id
              completionHandler: ^(CommentDTO 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.getCommentById(id, callback);

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

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

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

            try {
                CommentDTO result = apiInstance.getCommentById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getCommentById: " + 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->getCommentById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommentRestControllerApi->getCommentById: ', $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->getCommentById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommentRestControllerApi->getCommentById: $@\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_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentById: %s\n" % e)

extern crate CommentRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        ExerciseListPostDTO exerciseListPostDTO = ; // ExerciseListPostDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ExerciseListPostDTO exerciseListPostDTO = new ExerciseListPostDTO(); // ExerciseListPostDTO | 

try {
    final result = await api_instance.createExerciseList(exerciseListPostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createExerciseList: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

public class ExerciseListRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        ExerciseListPostDTO exerciseListPostDTO = ; // ExerciseListPostDTO | 

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

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

[apiInstance createExerciseListWith:exerciseListPostDTO
              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.ExerciseListRestControllerApi()
var exerciseListPostDTO = ; // {ExerciseListPostDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ExerciseListRestControllerApi();
            var exerciseListPostDTO = new ExerciseListPostDTO(); // ExerciseListPostDTO | 

            try {
                Object result = apiInstance.createExerciseList(exerciseListPostDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseListRestControllerApi.createExerciseList: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ExerciseListRestControllerApi();
$exerciseListPostDTO = ; // ExerciseListPostDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ExerciseListRestControllerApi->new();
my $exerciseListPostDTO = WWW::OPenAPIClient::Object::ExerciseListPostDTO->new(); # ExerciseListPostDTO | 

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

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

extern crate ExerciseListRestControllerApi;

pub fn main() {
    let exerciseListPostDTO = ; // ExerciseListPostDTO

    let mut context = ExerciseListRestControllerApi::Context::default();
    let result = client.createExerciseList(exerciseListPostDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteExerciseList(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteExerciseList: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

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

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

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

[apiInstance deleteExerciseListWith: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.ExerciseListRestControllerApi()
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.deleteExerciseList(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->deleteExerciseList(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseListRestControllerApi->deleteExerciseList: $@\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.ExerciseListRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseListRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getExerciseListById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getExerciseListById: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

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

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

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

[apiInstance getExerciseListByIdWith:id
              completionHandler: ^(ExerciseListDTO 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.ExerciseListRestControllerApi()
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.getExerciseListById(id, callback);

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

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

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

            try {
                ExerciseListDTO result = apiInstance.getExerciseListById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseListRestControllerApi.getExerciseListById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getExerciseListById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseListRestControllerApi->getExerciseListById: $@\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.ExerciseListRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseListRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long ownerId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelExerciseListDTO result = apiInstance.getLists(pageable, ownerId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseListRestControllerApi#getLists");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final Long ownerId = new Long(); // Long | 
final String nameFilter = new String(); // String | 

try {
    final result = await api_instance.getLists(pageable, ownerId, nameFilter);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLists: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

public class ExerciseListRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long ownerId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelExerciseListDTO result = apiInstance.getLists(pageable, ownerId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseListRestControllerApi#getLists");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ExerciseListRestControllerApi *apiInstance = [[ExerciseListRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
Long *ownerId = 789; //  (optional) (default to null)
String *nameFilter = nameFilter_example; //  (optional) (default to null)

[apiInstance getListsWith:pageable
    ownerId:ownerId
    nameFilter:nameFilter
              completionHandler: ^(PagedModelExerciseListDTO 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.ExerciseListRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'ownerId': 789, // {Long} 
  'nameFilter': nameFilter_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ExerciseListRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var ownerId = 789;  // Long |  (optional)  (default to null)
            var nameFilter = nameFilter_example;  // String |  (optional)  (default to null)

            try {
                PagedModelExerciseListDTO result = apiInstance.getLists(pageable, ownerId, nameFilter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseListRestControllerApi.getLists: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ExerciseListRestControllerApi();
$pageable = ; // Pageable | 
$ownerId = 789; // Long | 
$nameFilter = nameFilter_example; // String | 

try {
    $result = $api_instance->getLists($pageable, $ownerId, $nameFilter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExerciseListRestControllerApi->getLists: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ExerciseListRestControllerApi->new();
my $pageable = ; # Pageable | 
my $ownerId = 789; # Long | 
my $nameFilter = nameFilter_example; # String | 

eval {
    my $result = $api_instance->getLists(pageable => $pageable, ownerId => $ownerId, nameFilter => $nameFilter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseListRestControllerApi->getLists: $@\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.ExerciseListRestControllerApi()
pageable =  # Pageable |  (default to null)
ownerId = 789 # Long |  (optional) (default to null)
nameFilter = nameFilter_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_lists(pageable, ownerId=ownerId, nameFilter=nameFilter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseListRestControllerApi->getLists: %s\n" % e)

extern crate ExerciseListRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let ownerId = 789; // Long
    let nameFilter = nameFilter_example; // String

    let mut context = ExerciseListRestControllerApi::Context::default();
    let result = client.getLists(pageable, ownerId, nameFilter, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ExercisePostDTO exercisePostDTO = new ExercisePostDTO(); // ExercisePostDTO | 

try {
    final result = await api_instance.postExercise(id, exercisePostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postExercise: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

public class ExerciseListRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        Long id = 789; // Long | 
        ExercisePostDTO exercisePostDTO = ; // ExercisePostDTO | 

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

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

[apiInstance postExerciseWith:id
    exercisePostDTO:exercisePostDTO
              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.ExerciseListRestControllerApi()
var id = 789; // {Long} 
var exercisePostDTO = ; // {ExercisePostDTO} 

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->postExercise(id => $id, exercisePostDTO => $exercisePostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseListRestControllerApi->postExercise: $@\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.ExerciseListRestControllerApi()
id = 789 # Long |  (default to null)
exercisePostDTO =  # ExercisePostDTO | 

try:
    api_response = api_instance.post_exercise(id, exercisePostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseListRestControllerApi->postExercise: %s\n" % e)

extern crate ExerciseListRestControllerApi;

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

    let mut context = ExerciseListRestControllerApi::Context::default();
    let result = client.postExercise(id, exercisePostDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ExerciseListPostDTO exerciseListPostDTO = new ExerciseListPostDTO(); // ExerciseListPostDTO | 

try {
    final result = await api_instance.updateExerciseList(id, exerciseListPostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateExerciseList: $e\n');
}

import org.openapitools.client.api.ExerciseListRestControllerApi;

public class ExerciseListRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseListRestControllerApi apiInstance = new ExerciseListRestControllerApi();
        Long id = 789; // Long | 
        ExerciseListPostDTO exerciseListPostDTO = ; // ExerciseListPostDTO | 

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

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

[apiInstance updateExerciseListWith:id
    exerciseListPostDTO:exerciseListPostDTO
              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.ExerciseListRestControllerApi()
var id = 789; // {Long} 
var exerciseListPostDTO = ; // {ExerciseListPostDTO} 

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->updateExerciseList(id => $id, exerciseListPostDTO => $exerciseListPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseListRestControllerApi->updateExerciseList: $@\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.ExerciseListRestControllerApi()
id = 789 # Long |  (default to null)
exerciseListPostDTO =  # ExerciseListPostDTO | 

try:
    api_response = api_instance.update_exercise_list(id, exerciseListPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseListRestControllerApi->updateExerciseList: %s\n" % e)

extern crate ExerciseListRestControllerApi;

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

    let mut context = ExerciseListRestControllerApi::Context::default();
    let result = client.updateExerciseList(id, exerciseListPostDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final SolutionPostDTO solutionPostDTO = new SolutionPostDTO(); // SolutionPostDTO | 

try {
    final result = await api_instance.createSolution(id, solutionPostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createSolution: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

public class ExerciseRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseRestControllerApi apiInstance = new ExerciseRestControllerApi();
        Long id = 789; // Long | 
        SolutionPostDTO solutionPostDTO = ; // SolutionPostDTO | 

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

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

[apiInstance createSolutionWith:id
    solutionPostDTO:solutionPostDTO
              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.ExerciseRestControllerApi()
var id = 789; // {Long} 
var solutionPostDTO = ; // {SolutionPostDTO} 

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->createSolution(id => $id, solutionPostDTO => $solutionPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->createSolution: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)
solutionPostDTO =  # SolutionPostDTO | 

try:
    api_response = api_instance.create_solution(id, solutionPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseRestControllerApi->createSolution: %s\n" % e)

extern crate ExerciseRestControllerApi;

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

    let mut context = ExerciseRestControllerApi::Context::default();
    let result = client.createSolution(id, solutionPostDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteExercise(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteExercise: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

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

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

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

[apiInstance deleteExerciseWith: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.ExerciseRestControllerApi()
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.deleteExercise(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->deleteExercise(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->deleteExercise: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteExercisePdf(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteExercisePdf: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

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

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

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

[apiInstance deleteExercisePdfWith: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.ExerciseRestControllerApi()
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.deleteExercisePdf(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->deleteExercisePdf(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->deleteExercisePdf: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getExerciseById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getExerciseById: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

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

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

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

[apiInstance getExerciseByIdWith:id
              completionHandler: ^(ExerciseDTO 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.ExerciseRestControllerApi()
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.getExerciseById(id, callback);

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

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

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

            try {
                ExerciseDTO result = apiInstance.getExerciseById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseRestControllerApi.getExerciseById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getExerciseById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->getExerciseById: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getExercisePdf(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getExercisePdf: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

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

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

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

[apiInstance getExercisePdfWith: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.ExerciseRestControllerApi()
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.getExercisePdf(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->getExercisePdf(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->getExercisePdf: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ExerciseRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ExerciseRestControllerApi apiInstance = new ExerciseRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long listId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelExerciseDTO result = apiInstance.getExercises(pageable, listId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseRestControllerApi#getExercises");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final Long listId = new Long(); // Long | 
final String nameFilter = new String(); // String | 

try {
    final result = await api_instance.getExercises(pageable, listId, nameFilter);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getExercises: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

public class ExerciseRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseRestControllerApi apiInstance = new ExerciseRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long listId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelExerciseDTO result = apiInstance.getExercises(pageable, listId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseRestControllerApi#getExercises");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ExerciseRestControllerApi *apiInstance = [[ExerciseRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
Long *listId = 789; //  (optional) (default to null)
String *nameFilter = nameFilter_example; //  (optional) (default to null)

[apiInstance getExercisesWith:pageable
    listId:listId
    nameFilter:nameFilter
              completionHandler: ^(PagedModelExerciseDTO 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.ExerciseRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'listId': 789, // {Long} 
  'nameFilter': nameFilter_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ExerciseRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var listId = 789;  // Long |  (optional)  (default to null)
            var nameFilter = nameFilter_example;  // String |  (optional)  (default to null)

            try {
                PagedModelExerciseDTO result = apiInstance.getExercises(pageable, listId, nameFilter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseRestControllerApi.getExercises: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ExerciseRestControllerApi();
$pageable = ; // Pageable | 
$listId = 789; // Long | 
$nameFilter = nameFilter_example; // String | 

try {
    $result = $api_instance->getExercises($pageable, $listId, $nameFilter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExerciseRestControllerApi->getExercises: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ExerciseRestControllerApi->new();
my $pageable = ; # Pageable | 
my $listId = 789; # Long | 
my $nameFilter = nameFilter_example; # String | 

eval {
    my $result = $api_instance->getExercises(pageable => $pageable, listId => $listId, nameFilter => $nameFilter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->getExercises: $@\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.ExerciseRestControllerApi()
pageable =  # Pageable |  (default to null)
listId = 789 # Long |  (optional) (default to null)
nameFilter = nameFilter_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_exercises(pageable, listId=listId, nameFilter=nameFilter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseRestControllerApi->getExercises: %s\n" % e)

extern crate ExerciseRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let listId = 789; // Long
    let nameFilter = nameFilter_example; // String

    let mut context = ExerciseRestControllerApi::Context::default();
    let result = client.getExercises(pageable, listId, nameFilter, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ExercisePutDTO exercisePutDTO = new ExercisePutDTO(); // ExercisePutDTO | 

try {
    final result = await api_instance.updateExercise(id, exercisePutDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateExercise: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

public class ExerciseRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseRestControllerApi apiInstance = new ExerciseRestControllerApi();
        Long id = 789; // Long | 
        ExercisePutDTO exercisePutDTO = ; // ExercisePutDTO | 

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

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

[apiInstance updateExerciseWith:id
    exercisePutDTO:exercisePutDTO
              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.ExerciseRestControllerApi()
var id = 789; // {Long} 
var exercisePutDTO = ; // {ExercisePutDTO} 

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->updateExercise(id => $id, exercisePutDTO => $exercisePutDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->updateExercise: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)
exercisePutDTO =  # ExercisePutDTO | 

try:
    api_response = api_instance.update_exercise(id, exercisePutDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseRestControllerApi->updateExercise: %s\n" % e)

extern crate ExerciseRestControllerApi;

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

    let mut context = ExerciseRestControllerApi::Context::default();
    let result = client.updateExercise(id, exercisePutDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UploadExercisePdfRequest uploadExercisePdfRequest = new UploadExercisePdfRequest(); // UploadExercisePdfRequest | 

try {
    final result = await api_instance.uploadExercisePdf(id, uploadExercisePdfRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadExercisePdf: $e\n');
}

import org.openapitools.client.api.ExerciseRestControllerApi;

public class ExerciseRestControllerApiExample {
    public static void main(String[] args) {
        ExerciseRestControllerApi apiInstance = new ExerciseRestControllerApi();
        Long id = 789; // Long | 
        UploadExercisePdfRequest uploadExercisePdfRequest = ; // UploadExercisePdfRequest | 

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

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

[apiInstance uploadExercisePdfWith:id
    uploadExercisePdfRequest:uploadExercisePdfRequest
              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.ExerciseRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'uploadExercisePdfRequest':  // {UploadExercisePdfRequest} 
};

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->uploadExercisePdf(id => $id, uploadExercisePdfRequest => $uploadExercisePdfRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseRestControllerApi->uploadExercisePdf: $@\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.ExerciseRestControllerApi()
id = 789 # Long |  (default to null)
uploadExercisePdfRequest =  # UploadExercisePdfRequest |  (optional)

try:
    api_response = api_instance.upload_exercise_pdf(id, uploadExercisePdfRequest=uploadExercisePdfRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExerciseRestControllerApi->uploadExercisePdf: %s\n" % e)

extern crate ExerciseRestControllerApi;

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

    let mut context = ExerciseRestControllerApi::Context::default();
    let result = client.uploadExercisePdf(id, uploadExercisePdfRequest, &context).wait();

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

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

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

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

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

        try {
            byte[] result = apiInstance.downloadExercisePdf(exerciseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseWebControllerApi#downloadExercisePdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long exerciseId = new Long(); // Long | 

try {
    final result = await api_instance.downloadExercisePdf(exerciseId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->downloadExercisePdf: $e\n');
}

import org.openapitools.client.api.ExerciseWebControllerApi;

public class ExerciseWebControllerApiExample {
    public static void main(String[] args) {
        ExerciseWebControllerApi apiInstance = new ExerciseWebControllerApi();
        Long exerciseId = 789; // Long | 

        try {
            byte[] result = apiInstance.downloadExercisePdf(exerciseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExerciseWebControllerApi#downloadExercisePdf");
            e.printStackTrace();
        }
    }
}

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

[apiInstance downloadExercisePdfWith:exerciseId
              completionHandler: ^(byte[] 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.ExerciseWebControllerApi()
var exerciseId = 789; // {Long} 

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

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

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

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

            try {
                byte[] result = apiInstance.downloadExercisePdf(exerciseId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ExerciseWebControllerApi.downloadExercisePdf: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->downloadExercisePdf(exerciseId => $exerciseId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExerciseWebControllerApi->downloadExercisePdf: $@\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.ExerciseWebControllerApi()
exerciseId = 789 # Long |  (default to null)

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

extern crate ExerciseWebControllerApi;

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

    let mut context = ExerciseWebControllerApi::Context::default();
    let result = client.downloadExercisePdf(exerciseId, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getImage: $e\n');
}

import org.openapitools.client.api.ImageRestControllerApi;

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

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

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

[apiInstance getImageWith:id
              completionHandler: ^(ImageDTO 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.ImageRestControllerApi()
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.getImage(id, callback);

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

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

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

            try {
                ImageDTO result = apiInstance.getImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.getImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->getImage: $@\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.ImageRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ImageRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getImageFile(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getImageFile: $e\n');
}

import org.openapitools.client.api.ImageRestControllerApi;

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

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

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

[apiInstance getImageFileWith: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.ImageRestControllerApi()
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.getImageFile(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->getImageFile(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->getImageFile: $@\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.ImageRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate ImageRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageFileRequest replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest | 

try {
    final result = await api_instance.replaceImageFile(id, replaceImageFileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceImageFile: $e\n');
}

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

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

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

[apiInstance replaceImageFileWith:id
    replaceImageFileRequest:replaceImageFileRequest
              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.ImageRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceImageFileRequest':  // {ReplaceImageFileRequest} 
};

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->replaceImageFile(id => $id, replaceImageFileRequest => $replaceImageFileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->replaceImageFile: $@\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.ImageRestControllerApi()
id = 789 # Long |  (default to null)
replaceImageFileRequest =  # ReplaceImageFileRequest |  (optional)

try:
    api_response = api_instance.replace_image_file(id, replaceImageFileRequest=replaceImageFileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->replaceImageFile: %s\n" % e)

extern crate ImageRestControllerApi;

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

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.replaceImageFile(id, replaceImageFileRequest, &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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.logOut();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->logOut: $e\n');
}

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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.login(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->login: $e\n');
}

import org.openapitools.client.api.LoginRestControllerApi;

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

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            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 = ; // 

[apiInstance loginWith:loginRequest
              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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(loginRequest, 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 | 

            try {
                AuthResponse result = apiInstance.login(loginRequest);
                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 | 

try {
    $result = $api_instance->login($loginRequest);
    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 | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest);
    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 | 

try:
    api_response = api_instance.login(loginRequest)
    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 mut context = LoginRestControllerApi::Context::default();
    let result = client.login(loginRequest, &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();
        String refreshToken = refreshToken_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String refreshToken = new String(); // String | 

try {
    final result = await api_instance.refreshToken(refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->refreshToken: $e\n');
}

import org.openapitools.client.api.LoginRestControllerApi;

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

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

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

[apiInstance refreshTokenWith: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 opts = {
  '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.refreshToken(opts, callback);

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

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

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

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

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

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

try {
    $result = $api_instance->refreshToken($refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginRestControllerApi->refreshToken: ', $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 $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->refreshToken: $@\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()
refreshToken = refreshToken_example # String |  (optional) (default to null)

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

extern crate LoginRestControllerApi;

pub fn main() {
    let refreshToken = refreshToken_example; // String

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deletePostById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePostById: $e\n');
}

import org.openapitools.client.api.PostRestControllerApi;

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

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

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

[apiInstance deletePostByIdWith: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.PostRestControllerApi()
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.deletePostById(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->deletePostById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PostRestControllerApi->deletePostById: $@\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.PostRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate PostRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getPostById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPostById: $e\n');
}

import org.openapitools.client.api.PostRestControllerApi;

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

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

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

[apiInstance getPostByIdWith:id
              completionHandler: ^(PostDTO 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.PostRestControllerApi()
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.getPostById(id, callback);

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

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

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

            try {
                PostDTO result = apiInstance.getPostById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PostRestControllerApi.getPostById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getPostById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PostRestControllerApi->getPostById: $@\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.PostRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate PostRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        PostRestControllerApi apiInstance = new PostRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long currentUserId = 789; // Long | 

        try {
            PagedModelPostDTO result = apiInstance.getPosts(pageable, currentUserId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PostRestControllerApi#getPosts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final Long currentUserId = new Long(); // Long | 

try {
    final result = await api_instance.getPosts(pageable, currentUserId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPosts: $e\n');
}

import org.openapitools.client.api.PostRestControllerApi;

public class PostRestControllerApiExample {
    public static void main(String[] args) {
        PostRestControllerApi apiInstance = new PostRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long currentUserId = 789; // Long | 

        try {
            PagedModelPostDTO result = apiInstance.getPosts(pageable, currentUserId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PostRestControllerApi#getPosts");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
PostRestControllerApi *apiInstance = [[PostRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
Long *currentUserId = 789; //  (optional) (default to null)

[apiInstance getPostsWith:pageable
    currentUserId:currentUserId
              completionHandler: ^(PagedModelPostDTO 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.PostRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'currentUserId': 789 // {Long} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new PostRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var currentUserId = 789;  // Long |  (optional)  (default to null)

            try {
                PagedModelPostDTO result = apiInstance.getPosts(pageable, currentUserId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PostRestControllerApi.getPosts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PostRestControllerApi();
$pageable = ; // Pageable | 
$currentUserId = 789; // Long | 

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

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

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

eval {
    my $result = $api_instance->getPosts(pageable => $pageable, currentUserId => $currentUserId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PostRestControllerApi->getPosts: $@\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.PostRestControllerApi()
pageable =  # Pageable |  (default to null)
currentUserId = 789 # Long |  (optional) (default to null)

try:
    api_response = api_instance.get_posts(pageable, currentUserId=currentUserId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PostRestControllerApi->getPosts: %s\n" % e)

extern crate PostRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let currentUserId = 789; // Long

    let mut context = PostRestControllerApi::Context::default();
    let result = client.getPosts(pageable, currentUserId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        PostRestControllerApi apiInstance = new PostRestControllerApi();
        PostCreateDTO postCreateDTO = ; // PostCreateDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PostCreateDTO postCreateDTO = new PostCreateDTO(); // PostCreateDTO | 

try {
    final result = await api_instance.postNewPost(postCreateDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postNewPost: $e\n');
}

import org.openapitools.client.api.PostRestControllerApi;

public class PostRestControllerApiExample {
    public static void main(String[] args) {
        PostRestControllerApi apiInstance = new PostRestControllerApi();
        PostCreateDTO postCreateDTO = ; // PostCreateDTO | 

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

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

[apiInstance postNewPostWith:postCreateDTO
              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.PostRestControllerApi()
var postCreateDTO = ; // {PostCreateDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new PostRestControllerApi();
            var postCreateDTO = new PostCreateDTO(); // PostCreateDTO | 

            try {
                Object result = apiInstance.postNewPost(postCreateDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PostRestControllerApi.postNewPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PostRestControllerApi();
$postCreateDTO = ; // PostCreateDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PostRestControllerApi->new();
my $postCreateDTO = WWW::OPenAPIClient::Object::PostCreateDTO->new(); # PostCreateDTO | 

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

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

extern crate PostRestControllerApi;

pub fn main() {
    let postCreateDTO = ; // PostCreateDTO

    let mut context = PostRestControllerApi::Context::default();
    let result = client.postNewPost(postCreateDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.createSolutionPDF(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createSolutionPDF: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

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

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

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

[apiInstance createSolutionPDFWith: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.SolutionRestControllerApi()
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.createSolutionPDF(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->createSolutionPDF(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->createSolutionPDF: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate SolutionRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteSolutionById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteSolutionById: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

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

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

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

[apiInstance deleteSolutionByIdWith: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.SolutionRestControllerApi()
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.deleteSolutionById(id, callback);

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->deleteSolutionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->deleteSolutionById: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate SolutionRestControllerApi;

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

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

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

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

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

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

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

        try {
            array[CommentDTO] result = apiInstance.getCommentsForSolution(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SolutionRestControllerApi#getCommentsForSolution");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getCommentsForSolution(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getCommentsForSolution: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

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

        try {
            array[CommentDTO] result = apiInstance.getCommentsForSolution(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SolutionRestControllerApi#getCommentsForSolution");
            e.printStackTrace();
        }
    }
}

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

[apiInstance getCommentsForSolutionWith:id
              completionHandler: ^(array[CommentDTO] 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.SolutionRestControllerApi()
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.getCommentsForSolution(id, callback);

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

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

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

            try {
                array[CommentDTO] result = apiInstance.getCommentsForSolution(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SolutionRestControllerApi.getCommentsForSolution: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getCommentsForSolution(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->getCommentsForSolution: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate SolutionRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getSolutionById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSolutionById: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

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

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

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

[apiInstance getSolutionByIdWith:id
              completionHandler: ^(SolutionDTO 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.SolutionRestControllerApi()
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.getSolutionById(id, callback);

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

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

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

            try {
                SolutionDTO result = apiInstance.getSolutionById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SolutionRestControllerApi.getSolutionById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getSolutionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->getSolutionById: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)

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

extern crate SolutionRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final CommentPostDTO commentPostDTO = new CommentPostDTO(); // CommentPostDTO | 

try {
    final result = await api_instance.postComment(id, commentPostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->postComment: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

public class SolutionRestControllerApiExample {
    public static void main(String[] args) {
        SolutionRestControllerApi apiInstance = new SolutionRestControllerApi();
        Long id = 789; // Long | 
        CommentPostDTO commentPostDTO = ; // CommentPostDTO | 

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

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

[apiInstance postCommentWith:id
    commentPostDTO:commentPostDTO
              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.SolutionRestControllerApi()
var id = 789; // {Long} 
var commentPostDTO = ; // {CommentPostDTO} 

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->postComment(id => $id, commentPostDTO => $commentPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->postComment: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)
commentPostDTO =  # CommentPostDTO | 

try:
    api_response = api_instance.post_comment(id, commentPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SolutionRestControllerApi->postComment: %s\n" % e)

extern crate SolutionRestControllerApi;

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

    let mut context = SolutionRestControllerApi::Context::default();
    let result = client.postComment(id, commentPostDTO, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageFileRequest replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest | 

try {
    final result = await api_instance.uploadSolutionImage(id, replaceImageFileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadSolutionImage: $e\n');
}

import org.openapitools.client.api.SolutionRestControllerApi;

public class SolutionRestControllerApiExample {
    public static void main(String[] args) {
        SolutionRestControllerApi apiInstance = new SolutionRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

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

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

[apiInstance uploadSolutionImageWith:id
    replaceImageFileRequest:replaceImageFileRequest
              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.SolutionRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceImageFileRequest':  // {ReplaceImageFileRequest} 
};

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->uploadSolutionImage(id => $id, replaceImageFileRequest => $replaceImageFileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionRestControllerApi->uploadSolutionImage: $@\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.SolutionRestControllerApi()
id = 789 # Long |  (default to null)
replaceImageFileRequest =  # ReplaceImageFileRequest |  (optional)

try:
    api_response = api_instance.upload_solution_image(id, replaceImageFileRequest=replaceImageFileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SolutionRestControllerApi->uploadSolutionImage: %s\n" % e)

extern crate SolutionRestControllerApi;

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

    let mut context = SolutionRestControllerApi::Context::default();
    let result = client.uploadSolutionImage(id, replaceImageFileRequest, &context).wait();

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

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

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

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

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

        try {
            byte[] result = apiInstance.exportSolutionPdf(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SolutionWebControllerApi#exportSolutionPdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.exportSolutionPdf(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->exportSolutionPdf: $e\n');
}

import org.openapitools.client.api.SolutionWebControllerApi;

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

        try {
            byte[] result = apiInstance.exportSolutionPdf(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SolutionWebControllerApi#exportSolutionPdf");
            e.printStackTrace();
        }
    }
}

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

[apiInstance exportSolutionPdfWith:id
              completionHandler: ^(byte[] 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.SolutionWebControllerApi()
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.exportSolutionPdf(id, callback);

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

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

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

            try {
                byte[] result = apiInstance.exportSolutionPdf(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SolutionWebControllerApi.exportSolutionPdf: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->exportSolutionPdf(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SolutionWebControllerApi->exportSolutionPdf: $@\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.SolutionWebControllerApi()
id = 789 # Long |  (default to null)

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

extern crate SolutionWebControllerApi;

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

    let mut context = SolutionWebControllerApi::Context::default();
    let result = client.exportSolutionPdf(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 requesterId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long requesterId = new Long(); // Long | 

try {
    final result = await api_instance.acceptRequest(requesterId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->acceptRequest: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance acceptRequestWith:requesterId
              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 requesterId = 789; // {Long} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->acceptRequest($requesterId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->acceptRequest: ', $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 $requesterId = 789; # Long | 

eval {
    my $result = $api_instance->acceptRequest(requesterId => $requesterId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->acceptRequest: $@\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()
requesterId = 789 # Long |  (default to null)

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.acceptRequest(requesterId, &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();
        UserLoginDTO userLoginDTO = ; // UserLoginDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserLoginDTO userLoginDTO = new UserLoginDTO(); // UserLoginDTO | 

try {
    final result = await api_instance.createUser(userLoginDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance createUserWith:userLoginDTO
              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 userLoginDTO = ; // {UserLoginDTO} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->createUser($userLoginDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->createUser: ', $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 $userLoginDTO = WWW::OPenAPIClient::Object::UserLoginDTO->new(); # UserLoginDTO | 

eval {
    my $result = $api_instance->createUser(userLoginDTO => $userLoginDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->createUser: $@\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()
userLoginDTO =  # UserLoginDTO | 

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

extern crate UserRestControllerApi;

pub fn main() {
    let userLoginDTO = ; // UserLoginDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.createUser(userLoginDTO, &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 | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageFileRequest replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest | 

try {
    final result = await api_instance.createUserImage(id, replaceImageFileRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createUserImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance createUserImageWith:id
    replaceImageFileRequest:replaceImageFileRequest
              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 = {
  'replaceImageFileRequest':  // {ReplaceImageFileRequest} 
};

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

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

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

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

            try {
                Object result = apiInstance.createUserImage(id, replaceImageFileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.createUserImage: " + 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 | 
$replaceImageFileRequest = ; // ReplaceImageFileRequest | 

try {
    $result = $api_instance->createUserImage($id, $replaceImageFileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->createUserImage: ', $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 $replaceImageFileRequest = WWW::OPenAPIClient::Object::ReplaceImageFileRequest->new(); # ReplaceImageFileRequest | 

eval {
    my $result = $api_instance->createUserImage(id => $id, replaceImageFileRequest => $replaceImageFileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->createUserImage: $@\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)
replaceImageFileRequest =  # ReplaceImageFileRequest |  (optional)

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.createUserImage(id, replaceImageFileRequest, &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.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteUser(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteUser: $e\n');
}

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.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

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

[apiInstance deleteUserWith: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.deleteUser(id, callback);

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

namespace Example
{
    public class deleteUserExample
    {
        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.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUser: " + 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->deleteUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteUser: ', $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->deleteUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteUser: $@\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.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUser: %s\n" % e)

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteUser(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 {
            Object result = apiInstance.getFollowRequests();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowRequests");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getFollowRequests();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFollowRequests: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getFollowRequestsWithCompletionHandler: 
              ^(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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFollowRequests(callback);

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

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

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

            try {
                Object result = apiInstance.getFollowRequests();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getFollowRequests: " + 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->getFollowRequests();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getFollowRequests: ', $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->getFollowRequests();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getFollowRequests: $@\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.get_follow_requests()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getFollowRequests: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getFollowRequests(&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 {
            Object result = apiInstance.getFollowers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getFollowers();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFollowers: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getFollowersWithCompletionHandler: 
              ^(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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFollowers(callback);

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

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

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

            try {
                Object result = apiInstance.getFollowers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getFollowers: " + 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->getFollowers();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getFollowers: ', $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->getFollowers();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getFollowers: $@\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.get_followers()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getFollowers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getFollowers(&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 {
            Object result = apiInstance.getFollowing();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowing");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getFollowing();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFollowing: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getFollowingWithCompletionHandler: 
              ^(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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFollowing(callback);

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

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

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

            try {
                Object result = apiInstance.getFollowing();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getFollowing: " + 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->getFollowing();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getFollowing: ', $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->getFollowing();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getFollowing: $@\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.get_following()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getFollowing: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getFollowing(&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.getFollowingStatistics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowingStatistics");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getFollowingStatistics(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFollowingStatistics: $e\n');
}

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.getFollowingStatistics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowingStatistics");
            e.printStackTrace();
        }
    }
}

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

[apiInstance getFollowingStatisticsWith: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.getFollowingStatistics(id, callback);

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

namespace Example
{
    public class getFollowingStatisticsExample
    {
        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.getFollowingStatistics(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getFollowingStatistics: " + 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->getFollowingStatistics($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getFollowingStatistics: ', $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->getFollowingStatistics(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getFollowingStatistics: $@\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_following_statistics(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getFollowingStatistics: %s\n" % e)

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getFollowingStatistics(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 {
            Object result = apiInstance.getFollowingSuggestions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getFollowingSuggestions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getFollowingSuggestions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFollowingSuggestions: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getFollowingSuggestionsWithCompletionHandler: 
              ^(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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFollowingSuggestions(callback);

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

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

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

            try {
                Object result = apiInstance.getFollowingSuggestions();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getFollowingSuggestions: " + 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->getFollowingSuggestions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getFollowingSuggestions: ', $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->getFollowingSuggestions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getFollowingSuggestions: $@\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.get_following_suggestions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getFollowingSuggestions: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getFollowingSuggestions(&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 {
            UserDTO result = apiInstance.getUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUserById(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserById: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getUserByIdWith:id
              completionHandler: ^(UserDTO 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.getUserById(id, callback);

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

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

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

            try {
                UserDTO result = apiInstance.getUserById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserById: " + 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->getUserById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUserById: ', $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->getUserById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUserById: $@\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_user_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserById: %s\n" % e)

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUserById(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 {
            UserDTO result = apiInstance.getUserLogged();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserLogged");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getUserLogged();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserLogged: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance getUserLoggedWithCompletionHandler: 
              ^(UserDTO 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.getUserLogged(callback);

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

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

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

            try {
                UserDTO result = apiInstance.getUserLogged();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserLogged: " + 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->getUserLogged();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUserLogged: ', $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->getUserLogged();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUserLogged: $@\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.get_user_logged()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserLogged: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUserLogged(&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();
        Pageable pageable = ; // Pageable | 
        Long excludedId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelUserDTO result = apiInstance.getUsers(pageable, excludedId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final Long excludedId = new Long(); // Long | 
final String nameFilter = new String(); // String | 

try {
    final result = await api_instance.getUsers(pageable, excludedId, nameFilter);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUsers: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Pageable pageable = ; // Pageable | 
        Long excludedId = 789; // Long | 
        String nameFilter = nameFilter_example; // String | 

        try {
            PagedModelUserDTO result = apiInstance.getUsers(pageable, excludedId, nameFilter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
Long *excludedId = 789; //  (optional) (default to null)
String *nameFilter = nameFilter_example; //  (optional) (default to null)

[apiInstance getUsersWith:pageable
    excludedId:excludedId
    nameFilter:nameFilter
              completionHandler: ^(PagedModelUserDTO 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 pageable = ; // {Pageable} 
var opts = {
  'excludedId': 789, // {Long} 
  'nameFilter': nameFilter_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var excludedId = 789;  // Long |  (optional)  (default to null)
            var nameFilter = nameFilter_example;  // String |  (optional)  (default to null)

            try {
                PagedModelUserDTO result = apiInstance.getUsers(pageable, excludedId, nameFilter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$pageable = ; // Pageable | 
$excludedId = 789; // Long | 
$nameFilter = nameFilter_example; // String | 

try {
    $result = $api_instance->getUsers($pageable, $excludedId, $nameFilter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUsers: ', $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 $pageable = ; # Pageable | 
my $excludedId = 789; # Long | 
my $nameFilter = nameFilter_example; # String | 

eval {
    my $result = $api_instance->getUsers(pageable => $pageable, excludedId => $excludedId, nameFilter => $nameFilter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUsers: $@\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()
pageable =  # Pageable |  (default to null)
excludedId = 789 # Long |  (optional) (default to null)
nameFilter = nameFilter_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_users(pageable, excludedId=excludedId, nameFilter=nameFilter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUsers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let excludedId = 789; // Long
    let nameFilter = nameFilter_example; // String

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUsers(pageable, excludedId, nameFilter, &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 | 
        UserEditDTO userEditDTO = ; // UserEditDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UserEditDTO userEditDTO = new UserEditDTO(); // UserEditDTO | 

try {
    final result = await api_instance.putUser(id, userEditDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance putUserWith:id
    userEditDTO:userEditDTO
              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 userEditDTO = ; // {UserEditDTO} 

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

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

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

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

            try {
                Object result = apiInstance.putUser(id, userEditDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.putUser: " + 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 | 
$userEditDTO = ; // UserEditDTO | 

try {
    $result = $api_instance->putUser($id, $userEditDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->putUser: ', $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 $userEditDTO = WWW::OPenAPIClient::Object::UserEditDTO->new(); # UserEditDTO | 

eval {
    my $result = $api_instance->putUser(id => $id, userEditDTO => $userEditDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->putUser: $@\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)
userEditDTO =  # UserEditDTO | 

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.putUser(id, userEditDTO, &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 requesterId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long requesterId = new Long(); // Long | 

try {
    final result = await api_instance.rejectRequest(requesterId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->rejectRequest: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance rejectRequestWith:requesterId
              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 requesterId = 789; // {Long} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->rejectRequest($requesterId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->rejectRequest: ', $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 $requesterId = 789; # Long | 

eval {
    my $result = $api_instance->rejectRequest(requesterId => $requesterId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->rejectRequest: $@\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()
requesterId = 789 # Long |  (default to null)

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.rejectRequest(requesterId, &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 followerId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long followerId = new Long(); // Long | 

try {
    final result = await api_instance.removeFollower(followerId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->removeFollower: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance removeFollowerWith:followerId
              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 followerId = 789; // {Long} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->removeFollower($followerId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->removeFollower: ', $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 $followerId = 789; # Long | 

eval {
    my $result = $api_instance->removeFollower(followerId => $followerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->removeFollower: $@\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()
followerId = 789 # Long |  (default to null)

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.removeFollower(followerId, &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 targetId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long targetId = new Long(); // Long | 

try {
    final result = await api_instance.sendFollowRequest(targetId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sendFollowRequest: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance sendFollowRequestWith:targetId
              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 targetId = 789; // {Long} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->sendFollowRequest($targetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->sendFollowRequest: ', $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 $targetId = 789; # Long | 

eval {
    my $result = $api_instance->sendFollowRequest(targetId => $targetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->sendFollowRequest: $@\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()
targetId = 789 # Long |  (default to null)

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

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.sendFollowRequest(targetId, &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 targetId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long targetId = new Long(); // Long | 

try {
    final result = await api_instance.unfollowUser(targetId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->unfollowUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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

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

[apiInstance unfollowUserWith:targetId
              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 targetId = 789; // {Long} 

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

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

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

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

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

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

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

try {
    $result = $api_instance->unfollowUser($targetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->unfollowUser: ', $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 $targetId = 789; # Long | 

eval {
    my $result = $api_instance->unfollowUser(targetId => $targetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->unfollowUser: $@\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()
targetId = 789 # Long |  (default to null)

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

extern crate UserRestControllerApi;

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

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

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