# RoboCupMS - Robot API

## API and SDK Documentation

Version: 2.0.0

API umožnuje vytváření, upravování a registraci robotů. Každý robot je vytvářen na registraci týmu v soutěži.

# Default

# allConfirmedGet

Navrátí všechny roboty s potvrzenou registrací pro určity ročník soutěže

    /allConfirmed

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/allConfirmed?year=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 year = 56; // Integer | Ročnik soutěže

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer year = 56; // Integer | Ročnik soutěže

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročnik soutěže (default to null)

    // Navrátí všechny roboty s potvrzenou registrací pro určity ročník soutěže
    [apiInstance allConfirmedGetWith:year
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var year = 56; // {Integer} Ročnik soutěže

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročnik soutěže (default to null)

                try {
                    // Navrátí všechny roboty s potvrzenou registrací pro určity ročník soutěže
                    inline_response_200_1 result = apiInstance.allConfirmedGet(year);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.allConfirmedGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $year = 56; // Integer | Ročnik soutěže

    try {
        $result = $api_instance->allConfirmedGet($year);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->allConfirmedGet: ', $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 $year = 56; # Integer | Ročnik soutěže

    eval {
        my $result = $api_instance->allConfirmedGet(year => $year);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->allConfirmedGet: $@\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()
    year = 56 # Integer | Ročnik soutěže (default to null)

    try:
        # Navrátí všechny roboty s potvrzenou registrací pro určity ročník soutěže
        api_response = api_instance.all_confirmed_get(year)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->allConfirmedGet: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročnik soutěže Required

## Responses

###

# allGet

Navrátí všechny roboty vytvořene pro registraci týmu v určitém ročniku soutěže

Navrátí všechny vytvořené roboty pro danou registraci týmu, ve kterém se přihlášený uživatel nachází.

    /all

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/all?year=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 year = 56; // Integer | Ročnik soutěže, do které je tým registrovaný

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer year = 56; // Integer | Ročnik soutěže, do které je tým registrovaný

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročnik soutěže, do které je tým registrovaný (default to null)

    // Navrátí všechny roboty vytvořene pro registraci týmu v určitém ročniku soutěže
    [apiInstance allGetWith:year
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var year = 56; // {Integer} Ročnik soutěže, do které je tým registrovaný

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročnik soutěže, do které je tým registrovaný (default to null)

                try {
                    // Navrátí všechny roboty vytvořene pro registraci týmu v určitém ročniku soutěže
                    inline_response_200_1 result = apiInstance.allGet(year);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.allGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $year = 56; // Integer | Ročnik soutěže, do které je tým registrovaný

    try {
        $result = $api_instance->allGet($year);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->allGet: ', $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 $year = 56; # Integer | Ročnik soutěže, do které je tým registrovaný

    eval {
        my $result = $api_instance->allGet(year => $year);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->allGet: $@\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()
    year = 56 # Integer | Ročnik soutěže, do které je tým registrovaný (default to null)

    try:
        # Navrátí všechny roboty vytvořene pro registraci týmu v určitém ročniku soutěže
        api_response = api_instance.all_get(year)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->allGet: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročnik soutěže, do které je tým registrovaný Required

## Responses

###

# confirmRegistrationPut

Povrdí/nepovrdí registraci robota v disciplíně

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER, ASSISTANT].

    /confirmRegistration

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/confirmRegistration?id=56&confirmed=true"

    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 id = 56; // Integer | ID robota
            Boolean confirmed = true; // Boolean | Registrace potvrzena/nepotvrzena

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 56; // Integer | ID robota
            Boolean confirmed = true; // Boolean | Registrace potvrzena/nepotvrzena

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *id = 56; // ID robota (default to null)
    Boolean *confirmed = true; // Registrace potvrzena/nepotvrzena (default to null)

    // Povrdí/nepovrdí registraci robota v disciplíně
    [apiInstance confirmRegistrationPutWith:id
        confirmed:confirmed
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var id = 56; // {Integer} ID robota
    var confirmed = true; // {Boolean} Registrace potvrzena/nepotvrzena

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = 56;  // Integer | ID robota (default to null)
                var confirmed = true;  // Boolean | Registrace potvrzena/nepotvrzena (default to null)

                try {
                    // Povrdí/nepovrdí registraci robota v disciplíně
                    inline_response_200_2 result = apiInstance.confirmRegistrationPut(id, confirmed);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.confirmRegistrationPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $id = 56; // Integer | ID robota
    $confirmed = true; // Boolean | Registrace potvrzena/nepotvrzena

    try {
        $result = $api_instance->confirmRegistrationPut($id, $confirmed);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->confirmRegistrationPut: ', $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 $id = 56; # Integer | ID robota
    my $confirmed = true; # Boolean | Registrace potvrzena/nepotvrzena

    eval {
        my $result = $api_instance->confirmRegistrationPut(id => $id, confirmed => $confirmed);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->confirmRegistrationPut: $@\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()
    id = 56 # Integer | ID robota (default to null)
    confirmed = true # Boolean | Registrace potvrzena/nepotvrzena (default to null)

    try:
        # Povrdí/nepovrdí registraci robota v disciplíně
        api_response = api_instance.confirm_registration_put(id, confirmed)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->confirmRegistrationPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let id = 56; // Integer
        let confirmed = true; // Boolean

        let mut context = DefaultApi::Context::default();
        let result = client.confirmRegistrationPut(id, confirmed, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID robota Required
confirmed* | Boolean Registrace potvrzena/nepotvrzena Required

## Responses

###

# createPost

Vytvoří nového robota

Vytvořit robota může jakýkoli člen týmu. Robot je výtvářen na registraci týmu v určitém ročníku soutěže.

    /create

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/create?year=56" \
     -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();
            Integer year = 56; // Integer | Ročník soutěže
            InlineObject inlineObject = ; // InlineObject |

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer year = 56; // Integer | Ročník soutěže
            InlineObject inlineObject = ; // InlineObject |

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročník soutěže (default to null)
    InlineObject *inlineObject = ; //

    // Vytvoří nového robota
    [apiInstance createPostWith:year
        inlineObject:inlineObject
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var year = 56; // {Integer} Ročník soutěže
    var inlineObject = ; // {InlineObject}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročník soutěže (default to null)
                var inlineObject = new InlineObject(); // InlineObject |

                try {
                    // Vytvoří nového robota
                    inline_response_200_2 result = apiInstance.createPost(year, inlineObject);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.createPost: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $year = 56; // Integer | Ročník soutěže
    $inlineObject = ; // InlineObject |

    try {
        $result = $api_instance->createPost($year, $inlineObject);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->createPost: ', $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 $year = 56; # Integer | Ročník soutěže
    my $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject |

    eval {
        my $result = $api_instance->createPost(year => $year, inlineObject => $inlineObject);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->createPost: $@\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()
    year = 56 # Integer | Ročník soutěže (default to null)
    inlineObject =  # InlineObject |

    try:
        # Vytvoří nového robota
        api_response = api_instance.create_post(year, inlineObject)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->createPost: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Body parameters

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

Query parameters

Name | Description
--- | ---
year* | Integer Ročník soutěže Required

## Responses

###

# getGet

Navrátí robota s konkretním ID

    /get

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/get?id=id_example"

    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();
            String id = id_example; // String | ID robota

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String id = id_example; // String | ID robota

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *id = id_example; // ID robota (default to null)

    // Navrátí robota s konkretním ID
    [apiInstance getGetWith:id
                  completionHandler: ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var id = id_example; // {String} ID robota

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = id_example;  // String | ID robota (default to null)

                try {
                    // Navrátí robota s konkretním ID
                    inline_response_200 result = apiInstance.getGet(id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $id = id_example; // String | ID robota

    try {
        $result = $api_instance->getGet($id);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getGet: ', $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 $id = id_example; # String | ID robota

    eval {
        my $result = $api_instance->getGet(id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getGet: $@\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()
    id = id_example # String | ID robota (default to null)

    try:
        # Navrátí robota s konkretním ID
        api_response = api_instance.get_get(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let id = id_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | String ID robota Required

## Responses

###

# registerPut

Registruje robota do určité disciplíny

Registrovat robota může jakýkoli člen týmu. Robota je možné registrovat dokud soutěž nezačala.

    /register

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/register?robotID=56&disciplineID=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 robotID = 56; // Integer | ID robota
            Integer disciplineID = 56; // Integer | ID disciplíny, do které robota registrujeme

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer robotID = 56; // Integer | ID robota
            Integer disciplineID = 56; // Integer | ID disciplíny, do které robota registrujeme

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *robotID = 56; // ID robota (default to null)
    Integer *disciplineID = 56; // ID disciplíny, do které robota registrujeme (default to null)

    // Registruje robota do určité disciplíny
    [apiInstance registerPutWith:robotID
        disciplineID:disciplineID
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var robotID = 56; // {Integer} ID robota
    var disciplineID = 56; // {Integer} ID disciplíny, do které robota registrujeme

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var robotID = 56;  // Integer | ID robota (default to null)
                var disciplineID = 56;  // Integer | ID disciplíny, do které robota registrujeme (default to null)

                try {
                    // Registruje robota do určité disciplíny
                    inline_response_200_2 result = apiInstance.registerPut(robotID, disciplineID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.registerPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $robotID = 56; // Integer | ID robota
    $disciplineID = 56; // Integer | ID disciplíny, do které robota registrujeme

    try {
        $result = $api_instance->registerPut($robotID, $disciplineID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->registerPut: ', $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 $robotID = 56; # Integer | ID robota
    my $disciplineID = 56; # Integer | ID disciplíny, do které robota registrujeme

    eval {
        my $result = $api_instance->registerPut(robotID => $robotID, disciplineID => $disciplineID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->registerPut: $@\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()
    robotID = 56 # Integer | ID robota (default to null)
    disciplineID = 56 # Integer | ID disciplíny, do které robota registrujeme (default to null)

    try:
        # Registruje robota do určité disciplíny
        api_response = api_instance.register_put(robotID, disciplineID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->registerPut: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.registerPut(robotID, disciplineID, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
robotID* | Integer ID robota Required
disciplineID* | Integer ID disciplíny, do které robota registrujeme Required

## Responses

###

# removeDelete

Odstraní robota

Odstranit robota může jakýkoli člen týmu. Odstranění robota nebude možné ve chvíli, kdy již jeho registrace do discipliny byla povtrzena.

    /remove

### Usage and SDK Samples

    curl -X DELETE \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/remove?year=56&id=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 year = 56; // Integer | Ročník soutěže
            Integer id = 56; // Integer | ID robota, který bude odstraněn

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer year = 56; // Integer | Ročník soutěže
            Integer id = 56; // Integer | ID robota, který bude odstraněn

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročník soutěže (default to null)
    Integer *id = 56; // ID robota, který bude odstraněn (default to null)

    // Odstraní robota
    [apiInstance removeDeleteWith:year
        id:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var year = 56; // {Integer} Ročník soutěže
    var id = 56; // {Integer} ID robota, který bude odstraněn

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročník soutěže (default to null)
                var id = 56;  // Integer | ID robota, který bude odstraněn (default to null)

                try {
                    // Odstraní robota
                    inline_response_200_2 result = apiInstance.removeDelete(year, id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.removeDelete: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $year = 56; // Integer | Ročník soutěže
    $id = 56; // Integer | ID robota, který bude odstraněn

    try {
        $result = $api_instance->removeDelete($year, $id);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->removeDelete: ', $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 $year = 56; # Integer | Ročník soutěže
    my $id = 56; # Integer | ID robota, který bude odstraněn

    eval {
        my $result = $api_instance->removeDelete(year => $year, id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->removeDelete: $@\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()
    year = 56 # Integer | Ročník soutěže (default to null)
    id = 56 # Integer | ID robota, který bude odstraněn (default to null)

    try:
        # Odstraní robota
        api_response = api_instance.remove_delete(year, id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->removeDelete: %s\n" % e)

    extern crate DefaultApi;

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

        let mut context = DefaultApi::Context::default();
        let result = client.removeDelete(year, id, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročník soutěže Required
id* | Integer ID robota, který bude odstraněn Required

## Responses

###

# renamePut

Změní jméno robota

Změnit jméno robota může jakýkoli člen týmu. Jméno musí být v rámci ročníku unikátní.

    /rename

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/rename?year=56&id=56&name=name_example"

    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 year = 56; // Integer | Ročník soutěže
            Integer id = 56; // Integer | ID robota, kterému chceme změnit jméno
            String name = name_example; // String | Nové jméno robota (uníkátní v rámci ročníku soutěže)

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer year = 56; // Integer | Ročník soutěže
            Integer id = 56; // Integer | ID robota, kterému chceme změnit jméno
            String name = name_example; // String | Nové jméno robota (uníkátní v rámci ročníku soutěže)

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročník soutěže (default to null)
    Integer *id = 56; // ID robota, kterému chceme změnit jméno (default to null)
    String *name = name_example; // Nové jméno robota (uníkátní v rámci ročníku soutěže) (default to null)

    // Změní jméno robota
    [apiInstance renamePutWith:year
        id:id
        name:name
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var year = 56; // {Integer} Ročník soutěže
    var id = 56; // {Integer} ID robota, kterému chceme změnit jméno
    var name = name_example; // {String} Nové jméno robota (uníkátní v rámci ročníku soutěže)

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročník soutěže (default to null)
                var id = 56;  // Integer | ID robota, kterému chceme změnit jméno (default to null)
                var name = name_example;  // String | Nové jméno robota (uníkátní v rámci ročníku soutěže) (default to null)

                try {
                    // Změní jméno robota
                    inline_response_200_2 result = apiInstance.renamePut(year, id, name);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.renamePut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $year = 56; // Integer | Ročník soutěže
    $id = 56; // Integer | ID robota, kterému chceme změnit jméno
    $name = name_example; // String | Nové jméno robota (uníkátní v rámci ročníku soutěže)

    try {
        $result = $api_instance->renamePut($year, $id, $name);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->renamePut: ', $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 $year = 56; # Integer | Ročník soutěže
    my $id = 56; # Integer | ID robota, kterému chceme změnit jméno
    my $name = name_example; # String | Nové jméno robota (uníkátní v rámci ročníku soutěže)

    eval {
        my $result = $api_instance->renamePut(year => $year, id => $id, name => $name);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->renamePut: $@\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()
    year = 56 # Integer | Ročník soutěže (default to null)
    id = 56 # Integer | ID robota, kterému chceme změnit jméno (default to null)
    name = name_example # String | Nové jméno robota (uníkátní v rámci ročníku soutěže) (default to null)

    try:
        # Změní jméno robota
        api_response = api_instance.rename_put(year, id, name)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->renamePut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let year = 56; // Integer
        let id = 56; // Integer
        let name = name_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.renamePut(year, id, name, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročník soutěže Required
id* | Integer ID robota, kterému chceme změnit jméno Required
name* | String Nové jméno robota (uníkátní v rámci ročníku soutěže) Required

## Responses

###

# unregisterPut

Zruší registraci existujícího robota

Zrušit registraci robota může jakýkoli člen týmu. Zrušení registrace nebude možne pokud již byla povrzena.

    /unregister

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/robot/unregister?id=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 id = 56; // Integer | ID robota

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 56; // Integer | ID robota

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *id = 56; // ID robota (default to null)

    // Zruší registraci existujícího robota
    [apiInstance unregisterPutWith:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsRobotApi = require('robo_cup_ms_robot_api');

    // Create an instance of the API class
    var api = new RoboCupMsRobotApi.DefaultApi()
    var id = 56; // {Integer} ID robota

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = 56;  // Integer | ID robota (default to null)

                try {
                    // Zruší registraci existujícího robota
                    inline_response_200_2 result = apiInstance.unregisterPut(id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.unregisterPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $id = 56; // Integer | ID robota

    try {
        $result = $api_instance->unregisterPut($id);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->unregisterPut: ', $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 $id = 56; # Integer | ID robota

    eval {
        my $result = $api_instance->unregisterPut(id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->unregisterPut: $@\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()
    id = 56 # Integer | ID robota (default to null)

    try:
        # Zruší registraci existujícího robota
        api_response = api_instance.unregister_put(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->unregisterPut: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID robota Required

## Responses

###