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

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

public class CourseOfStudyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        CourseOfStudyApi apiInstance = new CourseOfStudyApi();
        Integer sEMUCZID = 56; // Integer | Id semestru
        try {
            APRPagedResultDto_LearningCourseDto result = apiInstance.getCoursesOfStudy(sEMUCZID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseOfStudyApi#getCoursesOfStudy");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CourseOfStudyApi;

public class CourseOfStudyApiExample {

    public static void main(String[] args) {
        CourseOfStudyApi apiInstance = new CourseOfStudyApi();
        Integer sEMUCZID = 56; // Integer | Id semestru
        try {
            APRPagedResultDto_LearningCourseDto result = apiInstance.getCoursesOfStudy(sEMUCZID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseOfStudyApi#getCoursesOfStudy");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *sEMUCZID = 56; // Id semestru (optional)

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

// Pobranie toków nauki
[apiInstance getCoursesOfStudyWith:sEMUCZID
              completionHandler: ^(APRPagedResultDto_LearningCourseDto output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.CourseOfStudyApi()

var opts = { 
  'sEMUCZID': 56 // {Integer} Id semestru
};

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

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

namespace Example
{
    public class getCoursesOfStudyExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new CourseOfStudyApi();
            var sEMUCZID = 56;  // Integer | Id semestru (optional) 

            try
            {
                // Pobranie toków nauki
                APRPagedResultDto_LearningCourseDto result = apiInstance.getCoursesOfStudy(sEMUCZID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CourseOfStudyApi.getCoursesOfStudy: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\CourseOfStudyApi();
$sEMUCZID = 56; // Integer | Id semestru

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::CourseOfStudyApi->new();
my $sEMUCZID = 56; # Integer | Id semestru

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.CourseOfStudyApi()
sEMUCZID = 56 # Integer | Id semestru (optional)

try: 
    # Pobranie toków nauki
    api_response = api_instance.get_courses_of_study(sEMUCZID=sEMUCZID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseOfStudyApi->getCoursesOfStudy: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CitizenshipCreateInputDto input = ; // CitizenshipCreateInputDto | Dane obywatelstwa
        try {
            'Integer' result = apiInstance.createCitizenShip(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCitizenShip");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CitizenshipCreateInputDto input = ; // CitizenshipCreateInputDto | Dane obywatelstwa
        try {
            'Integer' result = apiInstance.createCitizenShip(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCitizenShip");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CitizenshipCreateInputDto *input = ; // Dane obywatelstwa (optional)

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

// Dodanie obywatelstwa
[apiInstance createCitizenShipWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CitizenshipCreateInputDto} Dane obywatelstwa
};

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

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

namespace Example
{
    public class createCitizenShipExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CitizenshipCreateInputDto(); // CitizenshipCreateInputDto | Dane obywatelstwa (optional) 

            try
            {
                // Dodanie obywatelstwa
                'Integer' result = apiInstance.createCitizenShip(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.createCitizenShip: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CitizenshipCreateInputDto | Dane obywatelstwa

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CitizenshipCreateInputDto->new(); # CitizenshipCreateInputDto | Dane obywatelstwa

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CitizenshipCreateInputDto | Dane obywatelstwa (optional)

try: 
    # Dodanie obywatelstwa
    api_response = api_instance.create_citizen_ship(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->createCitizenShip: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CityCreateInputDto input = ; // CityCreateInputDto | Dane miasta
        try {
            'Integer' result = apiInstance.createCity(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCity");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CityCreateInputDto input = ; // CityCreateInputDto | Dane miasta
        try {
            'Integer' result = apiInstance.createCity(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCity");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CityCreateInputDto *input = ; // Dane miasta (optional)

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

// Dodanie miasta
[apiInstance createCityWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CityCreateInputDto} Dane miasta
};

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

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

namespace Example
{
    public class createCityExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CityCreateInputDto(); // CityCreateInputDto | Dane miasta (optional) 

            try
            {
                // Dodanie miasta
                'Integer' result = apiInstance.createCity(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.createCity: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CityCreateInputDto | Dane miasta

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CityCreateInputDto->new(); # CityCreateInputDto | Dane miasta

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CityCreateInputDto | Dane miasta (optional)

try: 
    # Dodanie miasta
    api_response = api_instance.create_city(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->createCity: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CountryCreateInputDto input = ; // CountryCreateInputDto | Dane kraju pochodzenia
        try {
            'Integer' result = apiInstance.createCountry(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCountry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CountryCreateInputDto input = ; // CountryCreateInputDto | Dane kraju pochodzenia
        try {
            'Integer' result = apiInstance.createCountry(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createCountry");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CountryCreateInputDto *input = ; // Dane kraju pochodzenia (optional)

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

// Dodanie kraju pochodzenia
[apiInstance createCountryWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CountryCreateInputDto} Dane kraju pochodzenia
};

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

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

namespace Example
{
    public class createCountryExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CountryCreateInputDto(); // CountryCreateInputDto | Dane kraju pochodzenia (optional) 

            try
            {
                // Dodanie kraju pochodzenia
                'Integer' result = apiInstance.createCountry(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.createCountry: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CountryCreateInputDto | Dane kraju pochodzenia

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CountryCreateInputDto->new(); # CountryCreateInputDto | Dane kraju pochodzenia

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CountryCreateInputDto | Dane kraju pochodzenia (optional)

try: 
    # Dodanie kraju pochodzenia
    api_response = api_instance.create_country(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->createCountry: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        HighschoolCreateInputDto input = ; // HighschoolCreateInputDto | Dane skzoły
        try {
            'Integer' result = apiInstance.createHighSchool(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createHighSchool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        HighschoolCreateInputDto input = ; // HighschoolCreateInputDto | Dane skzoły
        try {
            'Integer' result = apiInstance.createHighSchool(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createHighSchool");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

HighschoolCreateInputDto *input = ; // Dane skzoły (optional)

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

// Dodanie szkoły
[apiInstance createHighSchoolWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {HighschoolCreateInputDto} Dane skzoły
};

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

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

namespace Example
{
    public class createHighSchoolExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new HighschoolCreateInputDto(); // HighschoolCreateInputDto | Dane skzoły (optional) 

            try
            {
                // Dodanie szkoły
                'Integer' result = apiInstance.createHighSchool(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.createHighSchool: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // HighschoolCreateInputDto | Dane skzoły

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::HighschoolCreateInputDto->new(); # HighschoolCreateInputDto | Dane skzoły

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # HighschoolCreateInputDto | Dane skzoły (optional)

try: 
    # Dodanie szkoły
    api_response = api_instance.create_high_school(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->createHighSchool: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        NationalitieCreateInputDto input = ; // NationalitieCreateInputDto | Dane narodowości
        try {
            'Integer' result = apiInstance.createNationalitie(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createNationalitie");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        NationalitieCreateInputDto input = ; // NationalitieCreateInputDto | Dane narodowości
        try {
            'Integer' result = apiInstance.createNationalitie(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#createNationalitie");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

NationalitieCreateInputDto *input = ; // Dane narodowości (optional)

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

// Dodanie narodowości
[apiInstance createNationalitieWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {NationalitieCreateInputDto} Dane narodowości
};

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

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

namespace Example
{
    public class createNationalitieExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new NationalitieCreateInputDto(); // NationalitieCreateInputDto | Dane narodowości (optional) 

            try
            {
                // Dodanie narodowości
                'Integer' result = apiInstance.createNationalitie(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.createNationalitie: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // NationalitieCreateInputDto | Dane narodowości

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::NationalitieCreateInputDto->new(); # NationalitieCreateInputDto | Dane narodowości

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # NationalitieCreateInputDto | Dane narodowości (optional)

try: 
    # Dodanie narodowości
    api_response = api_instance.create_nationalitie(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->createNationalitie: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String cityName = cityName_example; // String | Nazwa miasta
        String countyName = countyName_example; // String | Nazwa powiatu
        Integer voivodeshipId = 56; // Integer | Id województwa
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CityDto] result = apiInstance.getCities(cityName, countyName, voivodeshipId, aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCities");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String cityName = cityName_example; // String | Nazwa miasta
        String countyName = countyName_example; // String | Nazwa powiatu
        Integer voivodeshipId = 56; // Integer | Id województwa
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CityDto] result = apiInstance.getCities(cityName, countyName, voivodeshipId, aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCities");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *cityName = cityName_example; // Nazwa miasta (optional)
String *countyName = countyName_example; // Nazwa powiatu (optional)
Integer *voivodeshipId = 56; // Id województwa (optional)
String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobiera liste miast.
[apiInstance getCitiesWith:cityName
    countyName:countyName
    voivodeshipId:voivodeshipId
    aPIVersion:aPIVersion
              completionHandler: ^(APRPagedResultDto[CityDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'cityName': cityName_example, // {String} Nazwa miasta
  'countyName': countyName_example, // {String} Nazwa powiatu
  'voivodeshipId': 56, // {Integer} Id województwa
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getCitiesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var cityName = cityName_example;  // String | Nazwa miasta (optional) 
            var countyName = countyName_example;  // String | Nazwa powiatu (optional) 
            var voivodeshipId = 56;  // Integer | Id województwa (optional) 
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobiera liste miast.
                APRPagedResultDto[CityDto] result = apiInstance.getCities(cityName, countyName, voivodeshipId, aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getCities: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$cityName = cityName_example; // String | Nazwa miasta
$countyName = countyName_example; // String | Nazwa powiatu
$voivodeshipId = 56; // Integer | Id województwa
$aPIVersion = aPIVersion_example; // String | 

try {
    $result = $api_instance->getCities($cityName, $countyName, $voivodeshipId, $aPIVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesApi->getCities: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $cityName = cityName_example; # String | Nazwa miasta
my $countyName = countyName_example; # String | Nazwa powiatu
my $voivodeshipId = 56; # Integer | Id województwa
my $aPIVersion = aPIVersion_example; # String | 

eval { 
    my $result = $api_instance->getCities(cityName => $cityName, countyName => $countyName, voivodeshipId => $voivodeshipId, aPIVersion => $aPIVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesApi->getCities: $@\n";
}

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
cityName = cityName_example # String | Nazwa miasta (optional)
countyName = countyName_example # String | Nazwa powiatu (optional)
voivodeshipId = 56 # Integer | Id województwa (optional)
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobiera liste miast.
    api_response = api_instance.get_cities(cityName=cityName, countyName=countyName, voivodeshipId=voivodeshipId, aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getCities: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CitizenshipDto] result = apiInstance.getCitizenships(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCitizenships");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CitizenshipDto] result = apiInstance.getCitizenships(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCitizenships");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobranie obywatelstw
[apiInstance getCitizenshipsWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[CitizenshipDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getCitizenshipsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobranie obywatelstw
                APRPagedResultDto[CitizenshipDto] result = apiInstance.getCitizenships(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getCitizenships: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobranie obywatelstw
    api_response = api_instance.get_citizenships(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getCitizenships: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CountryDto] result = apiInstance.getCountries(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCountries");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[CountryDto] result = apiInstance.getCountries(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getCountries");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobranie krajów
[apiInstance getCountriesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[CountryDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getCountriesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobranie krajów
                APRPagedResultDto[CountryDto] result = apiInstance.getCountries(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getCountries: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobranie krajów
    api_response = api_instance.get_countries(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getCountries: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[DepartamentDto] result = apiInstance.getDepartaments(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getDepartaments");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[DepartamentDto] result = apiInstance.getDepartaments(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getDepartaments");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Date *dMOD = 2013-10-20T19:20:30+01:00; // Data modyfikacji (optional)

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

[apiInstance getDepartamentsWith:dMOD
              completionHandler: ^(APRPagedResultDto[DepartamentDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'dMOD': 2013-10-20T19:20:30+01:00 // {Date} Data modyfikacji
};

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

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

namespace Example
{
    public class getDepartamentsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var dMOD = 2013-10-20T19:20:30+01:00;  // Date | Data modyfikacji (optional) 

            try
            {
                APRPagedResultDto[DepartamentDto] result = apiInstance.getDepartaments(dMOD);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getDepartaments: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $dMOD = 2013-10-20T19:20:30+01:00; # Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
dMOD = 2013-10-20T19:20:30+01:00 # Date | Data modyfikacji (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[FieldDto] result = apiInstance.getFields(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getFields");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[FieldDto] result = apiInstance.getFields(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getFields");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Date *dMOD = 2013-10-20T19:20:30+01:00; // Data modyfikacji (optional)

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

[apiInstance getFieldsWith:dMOD
              completionHandler: ^(APRPagedResultDto[FieldDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'dMOD': 2013-10-20T19:20:30+01:00 // {Date} Data modyfikacji
};

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

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

namespace Example
{
    public class getFieldsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var dMOD = 2013-10-20T19:20:30+01:00;  // Date | Data modyfikacji (optional) 

            try
            {
                APRPagedResultDto[FieldDto] result = apiInstance.getFields(dMOD);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getFields: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $dMOD = 2013-10-20T19:20:30+01:00; # Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
dMOD = 2013-10-20T19:20:30+01:00 # Date | Data modyfikacji (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[HighSchoolDto] result = apiInstance.getHighSchools(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getHighSchools");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[HighSchoolDto] result = apiInstance.getHighSchools(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getHighSchools");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobranie licuem
[apiInstance getHighSchoolsWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[HighSchoolDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getHighSchoolsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobranie licuem
                APRPagedResultDto[HighSchoolDto] result = apiInstance.getHighSchools(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getHighSchools: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobranie licuem
    api_response = api_instance.get_high_schools(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getHighSchools: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[NationalityDto] result = apiInstance.getNationalities(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getNationalities");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[NationalityDto] result = apiInstance.getNationalities(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getNationalities");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobranie narodowości
[apiInstance getNationalitiesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[NationalityDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getNationalitiesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobranie narodowości
                APRPagedResultDto[NationalityDto] result = apiInstance.getNationalities(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getNationalities: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobranie narodowości
    api_response = api_instance.get_nationalities(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getNationalities: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[ScientificTitleDto] result = apiInstance.getScientificTitles(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getScientificTitles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[ScientificTitleDto] result = apiInstance.getScientificTitles(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getScientificTitles");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// 
[apiInstance getScientificTitlesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[ScientificTitleDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getScientificTitlesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // 
                APRPagedResultDto[ScientificTitleDto] result = apiInstance.getScientificTitles(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getScientificTitles: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # 
    api_response = api_instance.get_scientific_titles(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getScientificTitles: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[SecondarySchoolCertificateTypeDto] result = apiInstance.getSecondarySchoolCertificateTypes(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSecondarySchoolCertificateTypes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[SecondarySchoolCertificateTypeDto] result = apiInstance.getSecondarySchoolCertificateTypes(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSecondarySchoolCertificateTypes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

[apiInstance getSecondarySchoolCertificateTypesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[SecondarySchoolCertificateTypeDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getSecondarySchoolCertificateTypesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                APRPagedResultDto[SecondarySchoolCertificateTypeDto] result = apiInstance.getSecondarySchoolCertificateTypes(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getSecondarySchoolCertificateTypes: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[SemesterDto] result = apiInstance.getSemesters(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSemesters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[SemesterDto] result = apiInstance.getSemesters(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSemesters");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Date *dMOD = 2013-10-20T19:20:30+01:00; // Data modyfikacji (optional)

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

[apiInstance getSemestersWith:dMOD
              completionHandler: ^(APRPagedResultDto[SemesterDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'dMOD': 2013-10-20T19:20:30+01:00 // {Date} Data modyfikacji
};

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

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

namespace Example
{
    public class getSemestersExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var dMOD = 2013-10-20T19:20:30+01:00;  // Date | Data modyfikacji (optional) 

            try
            {
                APRPagedResultDto[SemesterDto] result = apiInstance.getSemesters(dMOD);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getSemesters: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $dMOD = 2013-10-20T19:20:30+01:00; # Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
dMOD = 2013-10-20T19:20:30+01:00 # Date | Data modyfikacji (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[StatusDto] result = apiInstance.getStatuses(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getStatuses");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[StatusDto] result = apiInstance.getStatuses(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getStatuses");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

[apiInstance getStatusesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[StatusDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getStatusesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                APRPagedResultDto[StatusDto] result = apiInstance.getStatuses(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getStatuses: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[StudyDto] result = apiInstance.getStudies(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getStudies");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[StudyDto] result = apiInstance.getStudies(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getStudies");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

[apiInstance getStudiesWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[StudyDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getStudiesExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                APRPagedResultDto[StudyDto] result = apiInstance.getStudies(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getStudies: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[SubjectDto] result = apiInstance.getSubjects(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSubjects");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        Date dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji
        try {
            APRPagedResultDto[SubjectDto] result = apiInstance.getSubjects(dMOD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getSubjects");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Date *dMOD = 2013-10-20T19:20:30+01:00; // Data modyfikacji (optional)

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

[apiInstance getSubjectsWith:dMOD
              completionHandler: ^(APRPagedResultDto[SubjectDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'dMOD': 2013-10-20T19:20:30+01:00 // {Date} Data modyfikacji
};

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

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

namespace Example
{
    public class getSubjectsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var dMOD = 2013-10-20T19:20:30+01:00;  // Date | Data modyfikacji (optional) 

            try
            {
                APRPagedResultDto[SubjectDto] result = apiInstance.getSubjects(dMOD);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getSubjects: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$dMOD = 2013-10-20T19:20:30+01:00; // Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $dMOD = 2013-10-20T19:20:30+01:00; # Date | Data modyfikacji

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
dMOD = 2013-10-20T19:20:30+01:00 # Date | Data modyfikacji (optional)

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

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[VoivodeshipDto] result = apiInstance.getVoivodeships(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getVoivodeships");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        String aPIVersion = aPIVersion_example; // String | 
        try {
            APRPagedResultDto[VoivodeshipDto] result = apiInstance.getVoivodeships(aPIVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#getVoivodeships");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

String *aPIVersion = aPIVersion_example; //  (optional)

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

// Pobranie listy województw
[apiInstance getVoivodeshipsWith:aPIVersion
              completionHandler: ^(APRPagedResultDto[VoivodeshipDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'aPIVersion': aPIVersion_example // {String} 
};

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

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

namespace Example
{
    public class getVoivodeshipsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var aPIVersion = aPIVersion_example;  // String |  (optional) 

            try
            {
                // Pobranie listy województw
                APRPagedResultDto[VoivodeshipDto] result = apiInstance.getVoivodeships(aPIVersion);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.getVoivodeships: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$aPIVersion = aPIVersion_example; // String | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $aPIVersion = aPIVersion_example; # String | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
aPIVersion = aPIVersion_example # String |  (optional)

try: 
    # Pobranie listy województw
    api_response = api_instance.get_voivodeships(aPIVersion=aPIVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->getVoivodeships: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CitizenshipUpdateInputDto input = ; // CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa
        try {
            'Integer' result = apiInstance.updateCitizenship(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCitizenship");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CitizenshipUpdateInputDto input = ; // CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa
        try {
            'Integer' result = apiInstance.updateCitizenship(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCitizenship");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CitizenshipUpdateInputDto *input = ; // Dane do modyfikwacji obywatelstwa (optional)

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

// Modyfikacja obywatelstwa
[apiInstance updateCitizenshipWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CitizenshipUpdateInputDto} Dane do modyfikwacji obywatelstwa
};

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

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

namespace Example
{
    public class updateCitizenshipExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CitizenshipUpdateInputDto(); // CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa (optional) 

            try
            {
                // Modyfikacja obywatelstwa
                'Integer' result = apiInstance.updateCitizenship(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.updateCitizenship: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CitizenshipUpdateInputDto->new(); # CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CitizenshipUpdateInputDto | Dane do modyfikwacji obywatelstwa (optional)

try: 
    # Modyfikacja obywatelstwa
    api_response = api_instance.update_citizenship(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->updateCitizenship: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CityUpdateInputDto input = ; // CityUpdateInputDto | Dane do modyfikacji miasta
        try {
            'Integer' result = apiInstance.updateCity(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCity");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CityUpdateInputDto input = ; // CityUpdateInputDto | Dane do modyfikacji miasta
        try {
            'Integer' result = apiInstance.updateCity(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCity");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CityUpdateInputDto *input = ; // Dane do modyfikacji miasta (optional)

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

// Modyfikacja miasta
[apiInstance updateCityWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CityUpdateInputDto} Dane do modyfikacji miasta
};

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

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

namespace Example
{
    public class updateCityExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CityUpdateInputDto(); // CityUpdateInputDto | Dane do modyfikacji miasta (optional) 

            try
            {
                // Modyfikacja miasta
                'Integer' result = apiInstance.updateCity(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.updateCity: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CityUpdateInputDto | Dane do modyfikacji miasta

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CityUpdateInputDto->new(); # CityUpdateInputDto | Dane do modyfikacji miasta

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CityUpdateInputDto | Dane do modyfikacji miasta (optional)

try: 
    # Modyfikacja miasta
    api_response = api_instance.update_city(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->updateCity: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        CountryUpdateInputDto input = ; // CountryUpdateInputDto | Dane kraju, które zmienimy
        try {
            'Integer' result = apiInstance.updateCountry(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCountry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        CountryUpdateInputDto input = ; // CountryUpdateInputDto | Dane kraju, które zmienimy
        try {
            'Integer' result = apiInstance.updateCountry(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateCountry");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CountryUpdateInputDto *input = ; // Dane kraju, które zmienimy (optional)

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

// Modyfikacja kraju
[apiInstance updateCountryWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {CountryUpdateInputDto} Dane kraju, które zmienimy
};

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

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

namespace Example
{
    public class updateCountryExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new CountryUpdateInputDto(); // CountryUpdateInputDto | Dane kraju, które zmienimy (optional) 

            try
            {
                // Modyfikacja kraju
                'Integer' result = apiInstance.updateCountry(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.updateCountry: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // CountryUpdateInputDto | Dane kraju, które zmienimy

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::CountryUpdateInputDto->new(); # CountryUpdateInputDto | Dane kraju, które zmienimy

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # CountryUpdateInputDto | Dane kraju, które zmienimy (optional)

try: 
    # Modyfikacja kraju
    api_response = api_instance.update_country(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->updateCountry: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        HighschoolUpdateInputDto input = ; // HighschoolUpdateInputDto | Dane do modifykacji szkoły
        try {
            'Integer' result = apiInstance.updateHighSchool(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateHighSchool");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        HighschoolUpdateInputDto input = ; // HighschoolUpdateInputDto | Dane do modifykacji szkoły
        try {
            'Integer' result = apiInstance.updateHighSchool(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateHighSchool");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

HighschoolUpdateInputDto *input = ; // Dane do modifykacji szkoły (optional)

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

// Modyfikacja szkoły
[apiInstance updateHighSchoolWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {HighschoolUpdateInputDto} Dane do modifykacji szkoły
};

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

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

namespace Example
{
    public class updateHighSchoolExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new HighschoolUpdateInputDto(); // HighschoolUpdateInputDto | Dane do modifykacji szkoły (optional) 

            try
            {
                // Modyfikacja szkoły
                'Integer' result = apiInstance.updateHighSchool(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.updateHighSchool: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // HighschoolUpdateInputDto | Dane do modifykacji szkoły

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::HighschoolUpdateInputDto->new(); # HighschoolUpdateInputDto | Dane do modifykacji szkoły

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # HighschoolUpdateInputDto | Dane do modifykacji szkoły (optional)

try: 
    # Modyfikacja szkoły
    api_response = api_instance.update_high_school(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->updateHighSchool: %s\n" % e)

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

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

public class DictionariesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        DictionariesApi apiInstance = new DictionariesApi();
        NationalitieUpdateInputDto input = ; // NationalitieUpdateInputDto | Dane do modyfikacji narodowości
        try {
            'Integer' result = apiInstance.updateNationalitie(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateNationalitie");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesApi;

public class DictionariesApiExample {

    public static void main(String[] args) {
        DictionariesApi apiInstance = new DictionariesApi();
        NationalitieUpdateInputDto input = ; // NationalitieUpdateInputDto | Dane do modyfikacji narodowości
        try {
            'Integer' result = apiInstance.updateNationalitie(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesApi#updateNationalitie");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

NationalitieUpdateInputDto *input = ; // Dane do modyfikacji narodowości (optional)

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

// Modyfikacja narodowści
[apiInstance updateNationalitieWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.DictionariesApi()

var opts = { 
  'input':  // {NationalitieUpdateInputDto} Dane do modyfikacji narodowości
};

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

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

namespace Example
{
    public class updateNationalitieExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new DictionariesApi();
            var input = new NationalitieUpdateInputDto(); // NationalitieUpdateInputDto | Dane do modyfikacji narodowości (optional) 

            try
            {
                // Modyfikacja narodowści
                'Integer' result = apiInstance.updateNationalitie(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesApi.updateNationalitie: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\DictionariesApi();
$input = ; // NationalitieUpdateInputDto | Dane do modyfikacji narodowości

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::DictionariesApi->new();
my $input = WWW::SwaggerClient::Object::NationalitieUpdateInputDto->new(); # NationalitieUpdateInputDto | Dane do modyfikacji narodowości

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.DictionariesApi()
input =  # NationalitieUpdateInputDto | Dane do modyfikacji narodowości (optional)

try: 
    # Modyfikacja narodowści
    api_response = api_instance.update_nationalitie(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesApi->updateNationalitie: %s\n" % e)

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

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

public class StudentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        StudentApi apiInstance = new StudentApi();
        StudentCreateInputDto input = ; // StudentCreateInputDto | 
        try {
            'Integer' result = apiInstance.addStudent(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#addStudent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StudentApi;

public class StudentApiExample {

    public static void main(String[] args) {
        StudentApi apiInstance = new StudentApi();
        StudentCreateInputDto input = ; // StudentCreateInputDto | 
        try {
            'Integer' result = apiInstance.addStudent(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#addStudent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

StudentCreateInputDto *input = ; //  (optional)

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

// Dodanie studenta
[apiInstance addStudentWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.StudentApi()

var opts = { 
  'input':  // {StudentCreateInputDto} 
};

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

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

namespace Example
{
    public class addStudentExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new StudentApi();
            var input = new StudentCreateInputDto(); // StudentCreateInputDto |  (optional) 

            try
            {
                // Dodanie studenta
                'Integer' result = apiInstance.addStudent(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StudentApi.addStudent: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\StudentApi();
$input = ; // StudentCreateInputDto | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::StudentApi->new();
my $input = WWW::SwaggerClient::Object::StudentCreateInputDto->new(); # StudentCreateInputDto | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.StudentApi()
input =  # StudentCreateInputDto |  (optional)

try: 
    # Dodanie studenta
    api_response = api_instance.add_student(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StudentApi->addStudent: %s\n" % e)

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

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

public class StudentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        StudentApi apiInstance = new StudentApi();
        Integer studiaId = 56; // Integer | 
        Integer typgrId = 56; // Integer | 
        String specNazwa = specNazwa_example; // String | 
        try {
            APRPagedResultDto[SpecDto] result = apiInstance.getGroups(studiaId, typgrId, specNazwa);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#getGroups");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StudentApi;

public class StudentApiExample {

    public static void main(String[] args) {
        StudentApi apiInstance = new StudentApi();
        Integer studiaId = 56; // Integer | 
        Integer typgrId = 56; // Integer | 
        String specNazwa = specNazwa_example; // String | 
        try {
            APRPagedResultDto[SpecDto] result = apiInstance.getGroups(studiaId, typgrId, specNazwa);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#getGroups");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *studiaId = 56; //  (optional)
Integer *typgrId = 56; //  (optional)
String *specNazwa = specNazwa_example; //  (optional)

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

// Lista specjalności
[apiInstance getGroupsWith:studiaId
    typgrId:typgrId
    specNazwa:specNazwa
              completionHandler: ^(APRPagedResultDto[SpecDto] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.StudentApi()

var opts = { 
  'studiaId': 56, // {Integer} 
  'typgrId': 56, // {Integer} 
  'specNazwa': specNazwa_example // {String} 
};

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

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

namespace Example
{
    public class getGroupsExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new StudentApi();
            var studiaId = 56;  // Integer |  (optional) 
            var typgrId = 56;  // Integer |  (optional) 
            var specNazwa = specNazwa_example;  // String |  (optional) 

            try
            {
                // Lista specjalności
                APRPagedResultDto[SpecDto] result = apiInstance.getGroups(studiaId, typgrId, specNazwa);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StudentApi.getGroups: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\StudentApi();
$studiaId = 56; // Integer | 
$typgrId = 56; // Integer | 
$specNazwa = specNazwa_example; // String | 

try {
    $result = $api_instance->getGroups($studiaId, $typgrId, $specNazwa);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StudentApi->getGroups: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::StudentApi->new();
my $studiaId = 56; # Integer | 
my $typgrId = 56; # Integer | 
my $specNazwa = specNazwa_example; # String | 

eval { 
    my $result = $api_instance->getGroups(studiaId => $studiaId, typgrId => $typgrId, specNazwa => $specNazwa);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StudentApi->getGroups: $@\n";
}

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.StudentApi()
studiaId = 56 # Integer |  (optional)
typgrId = 56 # Integer |  (optional)
specNazwa = specNazwa_example # String |  (optional)

try: 
    # Lista specjalności
    api_response = api_instance.get_groups(studiaId=studiaId, typgrId=typgrId, specNazwa=specNazwa)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StudentApi->getGroups: %s\n" % e)

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

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

public class StudentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        StudentApi apiInstance = new StudentApi();
        StudentAddGroupInputDto input = ; // StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy
        try {
            'Integer' result = apiInstance.studentAddToGroup(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#studentAddToGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StudentApi;

public class StudentApiExample {

    public static void main(String[] args) {
        StudentApi apiInstance = new StudentApi();
        StudentAddGroupInputDto input = ; // StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy
        try {
            'Integer' result = apiInstance.studentAddToGroup(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#studentAddToGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

StudentAddGroupInputDto *input = ; // Dane potrzebne do zapisania do grupy (optional)

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

// Dodanie studenta do grupy
[apiInstance studentAddToGroupWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.StudentApi()

var opts = { 
  'input':  // {StudentAddGroupInputDto} Dane potrzebne do zapisania do grupy
};

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

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

namespace Example
{
    public class studentAddToGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new StudentApi();
            var input = new StudentAddGroupInputDto(); // StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy (optional) 

            try
            {
                // Dodanie studenta do grupy
                'Integer' result = apiInstance.studentAddToGroup(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StudentApi.studentAddToGroup: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\StudentApi();
$input = ; // StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::StudentApi->new();
my $input = WWW::SwaggerClient::Object::StudentAddGroupInputDto->new(); # StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.StudentApi()
input =  # StudentAddGroupInputDto | Dane potrzebne do zapisania do grupy (optional)

try: 
    # Dodanie studenta do grupy
    api_response = api_instance.student_add_to_group(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StudentApi->studentAddToGroup: %s\n" % e)

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

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

public class StudentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        StudentApi apiInstance = new StudentApi();
        StudentUpdateInputDto input = ; // StudentUpdateInputDto | 
        try {
            'Integer' result = apiInstance.updateStudent(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#updateStudent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StudentApi;

public class StudentApiExample {

    public static void main(String[] args) {
        StudentApi apiInstance = new StudentApi();
        StudentUpdateInputDto input = ; // StudentUpdateInputDto | 
        try {
            'Integer' result = apiInstance.updateStudent(input);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StudentApi#updateStudent");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

StudentUpdateInputDto *input = ; //  (optional)

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

// Modifikacja studenta
[apiInstance updateStudentWith:input
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.StudentApi()

var opts = { 
  'input':  // {StudentUpdateInputDto} 
};

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

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

namespace Example
{
    public class updateStudentExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new StudentApi();
            var input = new StudentUpdateInputDto(); // StudentUpdateInputDto |  (optional) 

            try
            {
                // Modifikacja studenta
                'Integer' result = apiInstance.updateStudent(input);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StudentApi.updateStudent: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\StudentApi();
$input = ; // StudentUpdateInputDto | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::StudentApi->new();
my $input = WWW::SwaggerClient::Object::StudentUpdateInputDto->new(); # StudentUpdateInputDto | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.StudentApi()
input =  # StudentUpdateInputDto |  (optional)

try: 
    # Modifikacja studenta
    api_response = api_instance.update_student(input=input)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StudentApi->updateStudent: %s\n" % e)

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

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

public class TokenAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: bearerAuth
        ApiKeyAuth bearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //bearerAuth.setApiKeyPrefix("Token");

        TokenAuthApi apiInstance = new TokenAuthApi();
        AuthenticateModel model = ; // AuthenticateModel | 
        try {
            AuthenticateResultModel result = apiInstance.apiTokenAuthAuthenticatePost(model);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenAuthApi#apiTokenAuthAuthenticatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TokenAuthApi;

public class TokenAuthApiExample {

    public static void main(String[] args) {
        TokenAuthApi apiInstance = new TokenAuthApi();
        AuthenticateModel model = ; // AuthenticateModel | 
        try {
            AuthenticateResultModel result = apiInstance.apiTokenAuthAuthenticatePost(model);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenAuthApi#apiTokenAuthAuthenticatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: bearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

AuthenticateModel *model = ; //  (optional)

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

[apiInstance apiTokenAuthAuthenticatePostWith:model
              completionHandler: ^(AuthenticateResultModel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ProAkademiaApi = require('pro_akademia_api');
var defaultClient = ProAkademiaApi.ApiClient.instance;

// Configure API key authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//bearerAuth.apiKeyPrefix['Authorization'] = "Token"

var api = new ProAkademiaApi.TokenAuthApi()

var opts = { 
  'model':  // {AuthenticateModel} 
};

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

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

namespace Example
{
    public class apiTokenAuthAuthenticatePostExample
    {
        public void main()
        {
            
            // Configure API key authorization: bearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new TokenAuthApi();
            var model = new AuthenticateModel(); // AuthenticateModel |  (optional) 

            try
            {
                AuthenticateResultModel result = apiInstance.apiTokenAuthAuthenticatePost(model);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenAuthApi.apiTokenAuthAuthenticatePost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: bearerAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\TokenAuthApi();
$model = ; // AuthenticateModel | 

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

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

# Configure API key authorization: bearerAuth
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::TokenAuthApi->new();
my $model = WWW::SwaggerClient::Object::AuthenticateModel->new(); # AuthenticateModel | 

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

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

# Configure API key authorization: bearerAuth
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.TokenAuthApi()
model =  # AuthenticateModel |  (optional)

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