# RoboCupMS - Auth API

## API and SDK Documentation

Version: 2.0.0

API slouží pro přihlášení, odhlášení a registraci uživatelů.

# Default

# loginPost

Přihlásí uživatele do systému

Uživatel, který se chce přihlásit do systému odešle svůj email a heslo. Pokud jsou přihlašovací údaje platné tak vygeneruje přistupový token. Token je platný do doby dokud se uživatel znovu nepřihlásí z jíného zařízení nebo se neodhlásí. Token se stavá automaticky neplatným po uplynutí definovaneho casu.

    /login

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/auth/login" \
     -d ''

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200 result = apiInstance.loginPost(inlineObject);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#loginPost");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200 result = apiInstance.loginPost(inlineObject);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#loginPost");
                e.printStackTrace();
            }
        }
    }

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

    // Přihlásí uživatele do systému
    [apiInstance loginPostWith:inlineObject
                  completionHandler: ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsAuthApi = require('robo_cup_ms_auth_api');

    // Create an instance of the API class
    var api = new RoboCupMsAuthApi.DefaultApi()
    var inlineObject = ; // {InlineObject}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var inlineObject = new InlineObject(); // InlineObject |

                try {
                    // Přihlásí uživatele do systému
                    inline_response_200 result = apiInstance.loginPost(inlineObject);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.loginPost: " + e.Message );
                }
            }
        }
    }

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

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

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

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

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

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

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

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    inlineObject =  # InlineObject |

    try:
        # Přihlásí uživatele do systému
        api_response = api_instance.login_post(inlineObject)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->loginPost: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.loginPost(inlineObject, &context).wait();

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
inlineObject * |

## Responses

###

# logoutPost

Odhlásí uživatele ze systému

Pro odhlášení využije přistupový token, podle kterého určí jakého uživatele ma odhlásit. Následně se přístupový token stává neplatným.

    /logout

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/auth/logout"

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

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

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

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

            try {
                inline_response_200_2 result = apiInstance.logoutPost();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#logoutPost");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                inline_response_200_2 result = apiInstance.logoutPost();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#logoutPost");
                e.printStackTrace();
            }
        }
    }

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

    // Odhlásí uživatele ze systému
    [apiInstance logoutPostWithCompletionHandler:
                  ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsAuthApi = require('robo_cup_ms_auth_api');

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

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

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

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

                try {
                    // Odhlásí uživatele ze systému
                    inline_response_200_2 result = apiInstance.logoutPost();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.logoutPost: " + e.Message );
                }
            }
        }
    }

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

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

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

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

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

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

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

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

    try:
        # Odhlásí uživatele ze systému
        api_response = api_instance.logout_post()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->logoutPost: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.logoutPost(&context).wait();

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

## Scopes

## Parameters

## Responses

###

# oAuth2GenerateTokenPost

Vygeneruje přístupový token pro uživatele s využitím OAuth2 autorizačního kódu

Pokud uživatel v systému neexistuje tak ho zaregistruje.

    /oAuth2GenerateToken

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/auth/oAuth2GenerateToken?redirectURI=56&code=56"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Integer redirectURI = 56; // Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru
            Integer code = 56; // Integer | Autorizační kód získaný po uspěšné autorizaci uživatele

            try {
                inline_response_200 result = apiInstance.oAuth2GenerateTokenPost(redirectURI, code);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#oAuth2GenerateTokenPost");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer redirectURI = 56; // Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru
            Integer code = 56; // Integer | Autorizační kód získaný po uspěšné autorizaci uživatele

            try {
                inline_response_200 result = apiInstance.oAuth2GenerateTokenPost(redirectURI, code);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#oAuth2GenerateTokenPost");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *redirectURI = 56; // Andresa, na kterou bude uživatel přesmerován z autorizačního serveru (default to null)
    Integer *code = 56; // Autorizační kód získaný po uspěšné autorizaci uživatele (default to null)

    // Vygeneruje přístupový token pro uživatele s využitím OAuth2 autorizačního kódu
    [apiInstance oAuth2GenerateTokenPostWith:redirectURI
        code:code
                  completionHandler: ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsAuthApi = require('robo_cup_ms_auth_api');

    // Create an instance of the API class
    var api = new RoboCupMsAuthApi.DefaultApi()
    var redirectURI = 56; // {Integer} Andresa, na kterou bude uživatel přesmerován z autorizačního serveru
    var code = 56; // {Integer} Autorizační kód získaný po uspěšné autorizaci uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var redirectURI = 56;  // Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru (default to null)
                var code = 56;  // Integer | Autorizační kód získaný po uspěšné autorizaci uživatele (default to null)

                try {
                    // Vygeneruje přístupový token pro uživatele s využitím OAuth2 autorizačního kódu
                    inline_response_200 result = apiInstance.oAuth2GenerateTokenPost(redirectURI, code);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.oAuth2GenerateTokenPost: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $redirectURI = 56; // Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru
    $code = 56; // Integer | Autorizační kód získaný po uspěšné autorizaci uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $redirectURI = 56; # Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru
    my $code = 56; # Integer | Autorizační kód získaný po uspěšné autorizaci uživatele

    eval {
        my $result = $api_instance->oAuth2GenerateTokenPost(redirectURI => $redirectURI, code => $code);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->oAuth2GenerateTokenPost: $@\n";
    }

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

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    redirectURI = 56 # Integer | Andresa, na kterou bude uživatel přesmerován z autorizačního serveru (default to null)
    code = 56 # Integer | Autorizační kód získaný po uspěšné autorizaci uživatele (default to null)

    try:
        # Vygeneruje přístupový token pro uživatele s využitím OAuth2 autorizačního kódu
        api_response = api_instance.o_auth2_generate_token_post(redirectURI, code)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->oAuth2GenerateTokenPost: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.oAuth2GenerateTokenPost(redirectURI, code, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
redirectURI* | Integer Andresa, na kterou bude uživatel přesmerován z autorizačního serveru Required
code* | Integer Autorizační kód získaný po uspěšné autorizaci uživatele Required

## Responses

###

# oAuth2Get

Vygeneruje odkaz pro autorizaci uživatele

Vygeneruje odkaz pro autorizaci uživatele. Po uspěšné autorizaci je uživatel přesměrován na specifikovanou adresu. Zde musí být odeslán POST request na endpoint serveru "/auth/oAuth2GenerateToken" s parametrem "code" a "redirectURI" jejihž hodnutu získá z aktualní URL. "redirectURI" bude předán parametrem "state".

    /oAuth2

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/auth/oAuth2?redirectURI=56"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Integer redirectURI = 56; // Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)

            try {
                inline_response_200_1 result = apiInstance.oAuth2Get(redirectURI);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#oAuth2Get");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer redirectURI = 56; // Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)

            try {
                inline_response_200_1 result = apiInstance.oAuth2Get(redirectURI);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#oAuth2Get");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *redirectURI = 56; // URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code) (optional) (default to null)

    // Vygeneruje odkaz pro autorizaci uživatele
    [apiInstance oAuth2GetWith:redirectURI
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsAuthApi = require('robo_cup_ms_auth_api');

    // Create an instance of the API class
    var api = new RoboCupMsAuthApi.DefaultApi()
    var opts = {
      'redirectURI': 56 // {Integer} URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)
    };

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var redirectURI = 56;  // Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code) (optional)  (default to null)

                try {
                    // Vygeneruje odkaz pro autorizaci uživatele
                    inline_response_200_1 result = apiInstance.oAuth2Get(redirectURI);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.oAuth2Get: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $redirectURI = 56; // Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $redirectURI = 56; # Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)

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

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

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    redirectURI = 56 # Integer | URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code) (optional) (default to null)

    try:
        # Vygeneruje odkaz pro autorizaci uživatele
        api_response = api_instance.o_auth2_get(redirectURI=redirectURI)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->oAuth2Get: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.oAuth2Get(redirectURI, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
redirectURI | Integer URL andresa, na kterou bude uživatel přesmerovan z autorizacniho serveru. (default https://localhost/auth/oauth2/code)

## Responses

###

# registerPost

Registruje nového uživatele

    /register

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/auth/register" \
     -d ''

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            InlineObject1 inlineObject1 = ; // InlineObject1 |

            try {
                inline_response_200_2 result = apiInstance.registerPost(inlineObject1);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#registerPost");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            InlineObject1 inlineObject1 = ; // InlineObject1 |

            try {
                inline_response_200_2 result = apiInstance.registerPost(inlineObject1);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#registerPost");
                e.printStackTrace();
            }
        }
    }

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

    // Registruje nového uživatele
    [apiInstance registerPostWith:inlineObject1
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsAuthApi = require('robo_cup_ms_auth_api');

    // Create an instance of the API class
    var api = new RoboCupMsAuthApi.DefaultApi()
    var inlineObject1 = ; // {InlineObject1}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var inlineObject1 = new InlineObject1(); // InlineObject1 |

                try {
                    // Registruje nového uživatele
                    inline_response_200_2 result = apiInstance.registerPost(inlineObject1);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.registerPost: " + e.Message );
                }
            }
        }
    }

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

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

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

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

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

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

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

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    inlineObject1 =  # InlineObject1 |

    try:
        # Registruje nového uživatele
        api_response = api_instance.register_post(inlineObject1)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->registerPost: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.registerPost(inlineObject1, &context).wait();

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
inlineObject1 * |

## Responses

###