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

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

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

        // Create an instance of the API class
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        ActivityDTO activityDTO = ; // ActivityDTO | 

        try {
            ActivityDTO result = apiInstance.createActivity(activityDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#createActivity");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ActivityDTO activityDTO = new ActivityDTO(); // ActivityDTO | 

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

import org.openapitools.client.api.ActivityRestControllerApi;

public class ActivityRestControllerApiExample {
    public static void main(String[] args) {
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        ActivityDTO activityDTO = ; // ActivityDTO | 

        try {
            ActivityDTO result = apiInstance.createActivity(activityDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#createActivity");
            e.printStackTrace();
        }
    }
}

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

// Create a new activity (Text data only)
[apiInstance createActivityWith:activityDTO
              completionHandler: ^(ActivityDTO 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.ActivityRestControllerApi()
var activityDTO = ; // {ActivityDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ActivityRestControllerApi();
            var activityDTO = new ActivityDTO(); // ActivityDTO | 

            try {
                // Create a new activity (Text data only)
                ActivityDTO result = apiInstance.createActivity(activityDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.createActivity: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ActivityRestControllerApi();
$activityDTO = ; // ActivityDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ActivityRestControllerApi->new();
my $activityDTO = WWW::OPenAPIClient::Object::ActivityDTO->new(); # ActivityDTO | 

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

try:
    # Create a new activity (Text data only)
    api_response = api_instance.create_activity(activityDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->createActivity: %s\n" % e)

extern crate ActivityRestControllerApi;

pub fn main() {
    let activityDTO = ; // ActivityDTO

    let mut context = ActivityRestControllerApi::Context::default();
    let result = client.createActivity(activityDTO, &context).wait();

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

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

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

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

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

        try {
            apiInstance.deleteActivity(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#deleteActivity");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

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

        try {
            apiInstance.deleteActivity(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#deleteActivity");
            e.printStackTrace();
        }
    }
}

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

// Delete an activity
[apiInstance deleteActivityWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete an activity
                apiInstance.deleteActivity(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.deleteActivity: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->deleteActivity($id);
} catch (Exception $e) {
    echo 'Exception when calling ActivityRestControllerApi->deleteActivity: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

try:
    # Delete an activity
    api_instance.delete_activity(id)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->deleteActivity: %s\n" % e)

extern crate ActivityRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

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

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

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

// Get an activity by its id
[apiInstance getActivityByIdWith:id
              completionHandler: ^(ActivityDTO 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.ActivityRestControllerApi()
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.getActivityById(id, callback);

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

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

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

            try {
                // Get an activity by its id
                ActivityDTO result = apiInstance.getActivityById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.getActivityById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get an activity by its id
    api_response = api_instance.get_activity_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->getActivityById: %s\n" % e)

extern crate ActivityRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

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

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

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

// Get the image of an activity
[apiInstance getActivityImageWith: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.ActivityRestControllerApi()
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.getActivityImage(id, callback);

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

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

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

            try {
                // Get the image of an activity
                byte[] result = apiInstance.getActivityImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.getActivityImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get the image of an activity
    api_response = api_instance.get_activity_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->getActivityImage: %s\n" % e)

extern crate ActivityRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

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

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

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

// Download the information PDF of an activity
[apiInstance getActivityPdfWith:id
              completionHandler: ^(File 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.ActivityRestControllerApi()
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.getActivityPdf(id, callback);

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

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

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

            try {
                // Download the information PDF of an activity
                File result = apiInstance.getActivityPdf(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.getActivityPdf: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Download the information PDF of an activity
    api_response = api_instance.get_activity_pdf(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->getActivityPdf: %s\n" % e)

extern crate ActivityRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageActivityDTO result = apiInstance.getAllActivities(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#getAllActivities");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

public class ActivityRestControllerApiExample {
    public static void main(String[] args) {
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageActivityDTO result = apiInstance.getAllActivities(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#getAllActivities");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ActivityRestControllerApi *apiInstance = [[ActivityRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

// Get all activities paginated
[apiInstance getAllActivitiesWith:pageable
              completionHandler: ^(PageActivityDTO 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.ActivityRestControllerApi()
var pageable = ; // {Pageable} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ActivityRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                // Get all activities paginated
                PageActivityDTO result = apiInstance.getAllActivities(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.getAllActivities: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all activities paginated
    api_response = api_instance.get_all_activities(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->getAllActivities: %s\n" % e)

extern crate ActivityRestControllerApi;

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

    let mut context = ActivityRestControllerApi::Context::default();
    let result = client.getAllActivities(pageable, &context).wait();

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

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

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

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

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

        try {
            ActivityDTO result = apiInstance.updateActivity(id, activityDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivity");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

public class ActivityRestControllerApiExample {
    public static void main(String[] args) {
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        Long id = 789; // Long | 
        ActivityDTO activityDTO = ; // ActivityDTO | 

        try {
            ActivityDTO result = apiInstance.updateActivity(id, activityDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivity");
            e.printStackTrace();
        }
    }
}

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

// Update an existing activity (Text data only)
[apiInstance updateActivityWith:id
    activityDTO:activityDTO
              completionHandler: ^(ActivityDTO 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.ActivityRestControllerApi()
var id = 789; // {Long} 
var activityDTO = ; // {ActivityDTO} 

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

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

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

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

            try {
                // Update an existing activity (Text data only)
                ActivityDTO result = apiInstance.updateActivity(id, activityDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.updateActivity: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update an existing activity (Text data only)
    api_response = api_instance.update_activity(id, activityDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->updateActivity: %s\n" % e)

extern crate ActivityRestControllerApi;

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

    let mut context = ActivityRestControllerApi::Context::default();
    let result = client.updateActivity(id, activityDTO, &context).wait();

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

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

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

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

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

        try {
            apiInstance.updateActivityImage(id, updateUserImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivityImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

public class ActivityRestControllerApiExample {
    public static void main(String[] args) {
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        Long id = 789; // Long | 
        UpdateUserImageRequest updateUserImageRequest = ; // UpdateUserImageRequest | 

        try {
            apiInstance.updateActivityImage(id, updateUserImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivityImage");
            e.printStackTrace();
        }
    }
}

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

// Update the image of an activity
[apiInstance updateActivityImageWith:id
    updateUserImageRequest:updateUserImageRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Update the image of an activity
                apiInstance.updateActivityImage(id, updateUserImageRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.updateActivityImage: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->updateActivityImage($id, $updateUserImageRequest);
} catch (Exception $e) {
    echo 'Exception when calling ActivityRestControllerApi->updateActivityImage: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->updateActivityImage(id => $id, updateUserImageRequest => $updateUserImageRequest);
};
if ($@) {
    warn "Exception when calling ActivityRestControllerApi->updateActivityImage: $@\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.ActivityRestControllerApi()
id = 789 # Long |  (default to null)
updateUserImageRequest =  # UpdateUserImageRequest |  (optional)

try:
    # Update the image of an activity
    api_instance.update_activity_image(id, updateUserImageRequest=updateUserImageRequest)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->updateActivityImage: %s\n" % e)

extern crate ActivityRestControllerApi;

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

    let mut context = ActivityRestControllerApi::Context::default();
    let result = client.updateActivityImage(id, updateUserImageRequest, &context).wait();

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

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

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

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

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

        try {
            apiInstance.updateActivityPdf(id, updateActivityPdfRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivityPdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ActivityRestControllerApi;

public class ActivityRestControllerApiExample {
    public static void main(String[] args) {
        ActivityRestControllerApi apiInstance = new ActivityRestControllerApi();
        Long id = 789; // Long | 
        UpdateActivityPdfRequest updateActivityPdfRequest = ; // UpdateActivityPdfRequest | 

        try {
            apiInstance.updateActivityPdf(id, updateActivityPdfRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivityRestControllerApi#updateActivityPdf");
            e.printStackTrace();
        }
    }
}

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

// Update the information PDF of an activity
[apiInstance updateActivityPdfWith:id
    updateActivityPdfRequest:updateActivityPdfRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Update the information PDF of an activity
                apiInstance.updateActivityPdf(id, updateActivityPdfRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ActivityRestControllerApi.updateActivityPdf: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->updateActivityPdf($id, $updateActivityPdfRequest);
} catch (Exception $e) {
    echo 'Exception when calling ActivityRestControllerApi->updateActivityPdf: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->updateActivityPdf(id => $id, updateActivityPdfRequest => $updateActivityPdfRequest);
};
if ($@) {
    warn "Exception when calling ActivityRestControllerApi->updateActivityPdf: $@\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.ActivityRestControllerApi()
id = 789 # Long |  (default to null)
updateActivityPdfRequest =  # UpdateActivityPdfRequest |  (optional)

try:
    # Update the information PDF of an activity
    api_instance.update_activity_pdf(id, updateActivityPdfRequest=updateActivityPdfRequest)
except ApiException as e:
    print("Exception when calling ActivityRestControllerApi->updateActivityPdf: %s\n" % e)

extern crate ActivityRestControllerApi;

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

    let mut context = ActivityRestControllerApi::Context::default();
    let result = client.updateActivityPdf(id, updateActivityPdfRequest, &context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFoundWithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound1();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound1();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound1");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound1WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound1(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound1();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound1(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound2");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound2WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound2(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound2();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound2(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound3();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound3");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound3();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound3");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound3WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound3(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound3();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound3: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound3(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound4();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound4");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound4();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound4");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound4WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound4(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound4();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound4: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound4(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound5();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound5");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound5();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound5");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound5WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound5(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound5();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound5: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound5(&context).wait();

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

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

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

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

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound6();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound6");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiErrorControllerApi;

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

        try {
            map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound6();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiErrorControllerApi#handleApiNotFound6");
            e.printStackTrace();
        }
    }
}

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

[apiInstance handleApiNotFound6WithCompletionHandler: 
              ^(map['String', oas_any_type_not_mapped] 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.ApiErrorControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleApiNotFound6(callback);

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

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

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

            try {
                map['String', oas_any_type_not_mapped] result = apiInstance.handleApiNotFound6();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiErrorControllerApi.handleApiNotFound6: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate ApiErrorControllerApi;

pub fn main() {

    let mut context = ApiErrorControllerApi::Context::default();
    let result = client.handleApiNotFound6(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AuthRestControllerApi apiInstance = new AuthRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            map['String', 'String'] result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthRestControllerApi#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.AuthRestControllerApi;

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

        try {
            map['String', 'String'] result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthRestControllerApi#login");
            e.printStackTrace();
        }
    }
}

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

[apiInstance loginWith:loginRequest
              completionHandler: ^(map['String', 'String'] 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.AuthRestControllerApi()
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 AuthRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                map['String', 'String'] result = apiInstance.login(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthRestControllerApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthRestControllerApi();
$loginRequest = ; // LoginRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthRestControllerApi->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 AuthRestControllerApi->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.AuthRestControllerApi()
loginRequest =  # LoginRequest | 

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

extern crate AuthRestControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = AuthRestControllerApi::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.BookingRestControllerApi;

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

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

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

        try {
            apiInstance.cancelBooking(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#cancelBooking");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingRestControllerApi;

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

        try {
            apiInstance.cancelBooking(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#cancelBooking");
            e.printStackTrace();
        }
    }
}

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

// Cancel/Delete a booking
[apiInstance cancelBookingWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Cancel/Delete a booking
                apiInstance.cancelBooking(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingRestControllerApi.cancelBooking: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->cancelBooking($id);
} catch (Exception $e) {
    echo 'Exception when calling BookingRestControllerApi->cancelBooking: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

try:
    # Cancel/Delete a booking
    api_instance.cancel_booking(id)
except ApiException as e:
    print("Exception when calling BookingRestControllerApi->cancelBooking: %s\n" % e)

extern crate BookingRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        BookingRestControllerApi apiInstance = new BookingRestControllerApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            BookingDTO result = apiInstance.createBooking(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#createBooking");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

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

import org.openapitools.client.api.BookingRestControllerApi;

public class BookingRestControllerApiExample {
    public static void main(String[] args) {
        BookingRestControllerApi apiInstance = new BookingRestControllerApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            BookingDTO result = apiInstance.createBooking(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#createBooking");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
BookingRestControllerApi *apiInstance = [[BookingRestControllerApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Create a new booking with specific date and time
[apiInstance createBookingWith:requestBody
              completionHandler: ^(BookingDTO 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.BookingRestControllerApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BookingRestControllerApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Create a new booking with specific date and time
                BookingDTO result = apiInstance.createBooking(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingRestControllerApi.createBooking: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BookingRestControllerApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BookingRestControllerApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->createBooking(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BookingRestControllerApi->createBooking: $@\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.BookingRestControllerApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Create a new booking with specific date and time
    api_response = api_instance.create_booking(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingRestControllerApi->createBooking: %s\n" % e)

extern crate BookingRestControllerApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = BookingRestControllerApi::Context::default();
    let result = client.createBooking(requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BookingRestControllerApi apiInstance = new BookingRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageBookingDTO result = apiInstance.getAllBookings(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#getAllBookings");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingRestControllerApi;

public class BookingRestControllerApiExample {
    public static void main(String[] args) {
        BookingRestControllerApi apiInstance = new BookingRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageBookingDTO result = apiInstance.getAllBookings(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingRestControllerApi#getAllBookings");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
BookingRestControllerApi *apiInstance = [[BookingRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

// Get all bookings paginated
[apiInstance getAllBookingsWith:pageable
              completionHandler: ^(PageBookingDTO 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.BookingRestControllerApi()
var pageable = ; // {Pageable} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BookingRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                // Get all bookings paginated
                PageBookingDTO result = apiInstance.getAllBookings(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingRestControllerApi.getAllBookings: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all bookings paginated
    api_response = api_instance.get_all_bookings(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingRestControllerApi->getAllBookings: %s\n" % e)

extern crate BookingRestControllerApi;

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

    let mut context = BookingRestControllerApi::Context::default();
    let result = client.getAllBookings(pageable, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingRestControllerApi;

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

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

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

// Get a booking by its id
[apiInstance getBookingByIdWith:id
              completionHandler: ^(BookingDTO 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.BookingRestControllerApi()
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.getBookingById(id, callback);

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

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

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

            try {
                // Get a booking by its id
                BookingDTO result = apiInstance.getBookingById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingRestControllerApi.getBookingById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a booking by its id
    api_response = api_instance.get_booking_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingRestControllerApi->getBookingById: %s\n" % e)

extern crate BookingRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long activityId = 789; // Long | 
        String comment = comment_example; // String | 
        Integer rating = 56; // Integer | 
        CreateReviewRequest createReviewRequest = ; // CreateReviewRequest | 

        try {
            ReviewDTO result = apiInstance.createReview(activityId, comment, rating, createReviewRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#createReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long activityId = new Long(); // Long | 
final String comment = new String(); // String | 
final Integer rating = new Integer(); // Integer | 
final CreateReviewRequest createReviewRequest = new CreateReviewRequest(); // CreateReviewRequest | 

try {
    final result = await api_instance.createReview(activityId, comment, rating, createReviewRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createReview: $e\n');
}

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long activityId = 789; // Long | 
        String comment = comment_example; // String | 
        Integer rating = 56; // Integer | 
        CreateReviewRequest createReviewRequest = ; // CreateReviewRequest | 

        try {
            ReviewDTO result = apiInstance.createReview(activityId, comment, rating, createReviewRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#createReview");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *activityId = 789; //  (default to null)
String *comment = comment_example; //  (default to null)
Integer *rating = 56; //  (default to null)
CreateReviewRequest *createReviewRequest = ; //  (optional)

// Create a new review for an activity
[apiInstance createReviewWith:activityId
    comment:comment
    rating:rating
    createReviewRequest:createReviewRequest
              completionHandler: ^(ReviewDTO 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.ReviewRestControllerApi()
var activityId = 789; // {Long} 
var comment = comment_example; // {String} 
var rating = 56; // {Integer} 
var opts = {
  'createReviewRequest':  // {CreateReviewRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var activityId = 789;  // Long |  (default to null)
            var comment = comment_example;  // String |  (default to null)
            var rating = 56;  // Integer |  (default to null)
            var createReviewRequest = new CreateReviewRequest(); // CreateReviewRequest |  (optional) 

            try {
                // Create a new review for an activity
                ReviewDTO result = apiInstance.createReview(activityId, comment, rating, createReviewRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.createReview: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$activityId = 789; // Long | 
$comment = comment_example; // String | 
$rating = 56; // Integer | 
$createReviewRequest = ; // CreateReviewRequest | 

try {
    $result = $api_instance->createReview($activityId, $comment, $rating, $createReviewRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->createReview: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $activityId = 789; # Long | 
my $comment = comment_example; # String | 
my $rating = 56; # Integer | 
my $createReviewRequest = WWW::OPenAPIClient::Object::CreateReviewRequest->new(); # CreateReviewRequest | 

eval {
    my $result = $api_instance->createReview(activityId => $activityId, comment => $comment, rating => $rating, createReviewRequest => $createReviewRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->createReview: $@\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.ReviewRestControllerApi()
activityId = 789 # Long |  (default to null)
comment = comment_example # String |  (default to null)
rating = 56 # Integer |  (default to null)
createReviewRequest =  # CreateReviewRequest |  (optional)

try:
    # Create a new review for an activity
    api_response = api_instance.create_review(activityId, comment, rating, createReviewRequest=createReviewRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->createReview: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {
    let activityId = 789; // Long
    let comment = comment_example; // String
    let rating = 56; // Integer
    let createReviewRequest = ; // CreateReviewRequest

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.createReview(activityId, comment, rating, createReviewRequest, &context).wait();

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

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

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

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

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

        try {
            apiInstance.deleteReview(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

        try {
            apiInstance.deleteReview(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}

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

// Delete a review (Owner or Admin only)
[apiInstance deleteReviewWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete a review (Owner or Admin only)
                apiInstance.deleteReview(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.deleteReview: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->deleteReview($id);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->deleteReview: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

try:
    # Delete a review (Owner or Admin only)
    api_instance.delete_review(id)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->deleteReview: %s\n" % e)

extern crate ReviewRestControllerApi;

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

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

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

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

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

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

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageReviewDTO result = apiInstance.getAllReviews(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getAllReviews");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageReviewDTO result = apiInstance.getAllReviews(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getAllReviews");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

// Get all reviews paginated
[apiInstance getAllReviewsWith:pageable
              completionHandler: ^(PageReviewDTO 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.ReviewRestControllerApi()
var pageable = ; // {Pageable} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                // Get all reviews paginated
                PageReviewDTO result = apiInstance.getAllReviews(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getAllReviews: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all reviews paginated
    api_response = api_instance.get_all_reviews(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getAllReviews: %s\n" % e)

extern crate ReviewRestControllerApi;

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

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getAllReviews(pageable, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

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

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

// Get a review by its id
[apiInstance getReviewByIdWith:id
              completionHandler: ^(ReviewDTO 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.ReviewRestControllerApi()
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.getReviewById(id, callback);

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

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

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

            try {
                // Get a review by its id
                ReviewDTO result = apiInstance.getReviewById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReviewById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a review by its id
    api_response = api_instance.get_review_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReviewById: %s\n" % e)

extern crate ReviewRestControllerApi;

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

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

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

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

// Get the image attached to a review
[apiInstance getReviewImageWith: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.ReviewRestControllerApi()
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.getReviewImage(id, callback);

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

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

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

            try {
                // Get the image attached to a review
                byte[] result = apiInstance.getReviewImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReviewImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get the image attached to a review
    api_response = api_instance.get_review_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReviewImage: %s\n" % e)

extern crate ReviewRestControllerApi;

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

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getReviewImage(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();
        map[String, String] requestBody = Object; // map[String, String] | 

        try {
            UserResponseDTO result = apiInstance.createUser(requestBody);
            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 map[String, String] requestBody = new map[String, String](); // map[String, String] | 

try {
    final result = await api_instance.createUser(requestBody);
    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();
        map[String, String] requestBody = Object; // map[String, String] | 

        try {
            UserResponseDTO result = apiInstance.createUser(requestBody);
            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];
map[String, String] *requestBody = Object; // 

// Create a new user
[apiInstance createUserWith:requestBody
              completionHandler: ^(UserResponseDTO 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 requestBody = Object; // {map[String, String]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createUser(requestBody, 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 requestBody = new map[String, String](); // map[String, String] | 

            try {
                // Create a new user
                UserResponseDTO result = apiInstance.createUser(requestBody);
                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();
$requestBody = Object; // map[String, String] | 

try {
    $result = $api_instance->createUser($requestBody);
    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 $requestBody = WWW::OPenAPIClient::Object::map[String, String]->new(); # map[String, String] | 

eval {
    my $result = $api_instance->createUser(requestBody => $requestBody);
    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()
requestBody = Object # map[String, String] | 

try:
    # Create a new user
    api_response = api_instance.create_user(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let requestBody = Object; // map[String, String]

    let mut context = UserRestControllerApi::Context::default();
    let result = client.createUser(requestBody, &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 {
            apiInstance.deleteUser(id);
        } 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 {
            apiInstance.deleteUser(id);
        } 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)

// Delete a user by id
[apiInstance deleteUserWith:id
              completionHandler: ^(NSError* error) {
    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.');
  }
};
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 {
                // Delete a user by id
                apiInstance.deleteUser(id);
            } 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 {
    $api_instance->deleteUser($id);
} 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 {
    $api_instance->deleteUser(id => $id);
};
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:
    # Delete a user by id
    api_instance.delete_user(id)
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();
        Long id = 789; // Long | 

        try {
            UserResponseDTO 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 {
            UserResponseDTO 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)

// Get a user by its id
[apiInstance getUserByIdWith:id
              completionHandler: ^(UserResponseDTO 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 {
                // Get a user by its id
                UserResponseDTO 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:
    # Get a user by its id
    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();
        Long id = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.getUserImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserImage: $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 {
            byte[] result = apiInstance.getUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserImage");
            e.printStackTrace();
        }
    }
}

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

// Get the user's profile image
[apiInstance getUserImageWith: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.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.getUserImage(id, callback);

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

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

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

            try {
                // Get the user's profile image
                byte[] result = apiInstance.getUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserImage: " + 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->getUserImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUserImage: ', $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->getUserImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUserImage: $@\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:
    # Get the user's profile image
    api_response = api_instance.get_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUserImage(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();
        Pageable pageable = ; // Pageable | 

        try {
            PageUserResponseDTO result = apiInstance.getUsers(pageable);
            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 | 

try {
    final result = await api_instance.getUsers(pageable);
    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 | 

        try {
            PageUserResponseDTO result = apiInstance.getUsers(pageable);
            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)

// Get a list of all users paginated
[apiInstance getUsersWith:pageable
              completionHandler: ^(PageUserResponseDTO 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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers(pageable, 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)

            try {
                // Get a list of all users paginated
                PageUserResponseDTO result = apiInstance.getUsers(pageable);
                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 | 

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

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

try:
    # Get a list of all users paginated
    api_response = api_instance.get_users(pageable)
    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 mut context = UserRestControllerApi::Context::default();
    let result = client.getUsers(pageable, &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 | 
        UserResponseDTO userResponseDTO = ; // UserResponseDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.updateUser(id, userResponseDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateUser: $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 | 
        UserResponseDTO userResponseDTO = ; // UserResponseDTO | 

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

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

// Update an existing user profile
[apiInstance updateUserWith:id
    userResponseDTO:userResponseDTO
              completionHandler: ^(UserResponseDTO 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 userResponseDTO = ; // {UserResponseDTO} 

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

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

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

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

            try {
                // Update an existing user profile
                UserResponseDTO result = apiInstance.updateUser(id, userResponseDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.updateUser: " + 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 | 
$userResponseDTO = ; // UserResponseDTO | 

try {
    $result = $api_instance->updateUser($id, $userResponseDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->updateUser: ', $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 $userResponseDTO = WWW::OPenAPIClient::Object::UserResponseDTO->new(); # UserResponseDTO | 

eval {
    my $result = $api_instance->updateUser(id => $id, userResponseDTO => $userResponseDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->updateUser: $@\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)
userResponseDTO =  # UserResponseDTO | 

try:
    # Update an existing user profile
    api_response = api_instance.update_user(id, userResponseDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->updateUser: %s\n" % e)

extern crate UserRestControllerApi;

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.updateUser(id, userResponseDTO, &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 | 
        UpdateUserImageRequest updateUserImageRequest = ; // UpdateUserImageRequest | 

        try {
            apiInstance.updateUserImage(id, updateUserImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#updateUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.updateUserImage(id, updateUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateUserImage: $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 | 
        UpdateUserImageRequest updateUserImageRequest = ; // UpdateUserImageRequest | 

        try {
            apiInstance.updateUserImage(id, updateUserImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#updateUserImage");
            e.printStackTrace();
        }
    }
}

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

// Upload or update a profile image for a user
[apiInstance updateUserImageWith:id
    updateUserImageRequest:updateUserImageRequest
              completionHandler: ^(NSError* error) {
    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 = {
  'updateUserImageRequest':  // {UpdateUserImageRequest} 
};

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

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

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

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

            try {
                // Upload or update a profile image for a user
                apiInstance.updateUserImage(id, updateUserImageRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.updateUserImage: " + 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 | 
$updateUserImageRequest = ; // UpdateUserImageRequest | 

try {
    $api_instance->updateUserImage($id, $updateUserImageRequest);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->updateUserImage: ', $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 $updateUserImageRequest = WWW::OPenAPIClient::Object::UpdateUserImageRequest->new(); # UpdateUserImageRequest | 

eval {
    $api_instance->updateUserImage(id => $id, updateUserImageRequest => $updateUserImageRequest);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->updateUserImage: $@\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)
updateUserImageRequest =  # UpdateUserImageRequest |  (optional)

try:
    # Upload or update a profile image for a user
    api_instance.update_user_image(id, updateUserImageRequest=updateUserImageRequest)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->updateUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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