# RoboCupMS - Team Registration API

## API and SDK Documentation

Version: 2.0.0

API zajištuje přihlášování týmů, do konkrétních ročníků soutěže.

# Default

# allGet

Navrátí všechný registrace 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/teamRegistration/all"

    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 result = apiInstance.allGet();
                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();

            try {
                inline_response_200 result = apiInstance.allGet();
                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];

    // Navrátí všechný registrace týmu, ve kterém se přihlášený uživatel nachází
    [apiInstance allGetWithCompletionHandler:
                  ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamRegistrationApi = require('robo_cup_ms_team_registration_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamRegistrationApi.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.allGet(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();

                try {
                    // Navrátí všechný registrace týmu, ve kterém se přihlášený uživatel nachází
                    inline_response_200 result = apiInstance.allGet();
                    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();

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

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

    try:
        # Navrátí všechný registrace týmu, ve kterém se přihlášený uživatel nachází
        api_response = api_instance.all_get()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->allGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

# changeCategoryPut

Změní kategorii týmu

Změní kategorii týmu. Změna neni nijak omezována věkem a tak je možné zvolit libovolnou kategorii. Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER, ASSISTANT].

    /changeCategory

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/teamRegistration/changeCategory?id=56&year=56&category=category_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 id = 56; // Integer | ID týmu
            Integer year = 56; // Integer | Ročník soutěže
            String category = category_example; // String | Nová kategorie, ve které bude tým soutežit

            try {
                inline_response_200_1 result = apiInstance.changeCategoryPut(id, year, category);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#changeCategoryPut");
                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 týmu
            Integer year = 56; // Integer | Ročník soutěže
            String category = category_example; // String | Nová kategorie, ve které bude tým soutežit

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *id = 56; // ID týmu (default to null)
    Integer *year = 56; // Ročník soutěže (default to null)
    String *category = category_example; // Nová kategorie, ve které bude tým soutežit (default to null)

    // Změní kategorii týmu
    [apiInstance changeCategoryPutWith:id
        year:year
        category:category
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamRegistrationApi = require('robo_cup_ms_team_registration_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamRegistrationApi.DefaultApi()
    var id = 56; // {Integer} ID týmu
    var year = 56; // {Integer} Ročník soutěže
    var category = category_example; // {String} Nová kategorie, ve které bude tým soutežit

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = 56;  // Integer | ID týmu (default to null)
                var year = 56;  // Integer | Ročník soutěže (default to null)
                var category = category_example;  // String | Nová kategorie, ve které bude tým soutežit (default to null)

                try {
                    // Změní kategorii týmu
                    inline_response_200_1 result = apiInstance.changeCategoryPut(id, year, category);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.changeCategoryPut: " + 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 týmu
    $year = 56; // Integer | Ročník soutěže
    $category = category_example; // String | Nová kategorie, ve které bude tým soutežit

    try {
        $result = $api_instance->changeCategoryPut($id, $year, $category);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->changeCategoryPut: ', $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 týmu
    my $year = 56; # Integer | Ročník soutěže
    my $category = category_example; # String | Nová kategorie, ve které bude tým soutežit

    eval {
        my $result = $api_instance->changeCategoryPut(id => $id, year => $year, category => $category);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->changeCategoryPut: $@\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 týmu (default to null)
    year = 56 # Integer | Ročník soutěže (default to null)
    category = category_example # String | Nová kategorie, ve které bude tým soutežit (default to null)

    try:
        # Změní kategorii týmu
        api_response = api_instance.change_category_put(id, year, category)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->changeCategoryPut: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID týmu Required
year* | Integer Ročník soutěže Required
category* | String Nová kategorie, ve které bude tým soutežit Required

## Responses

###

# joinCategoryPut

Sloučí dvě různé kategorie dohromady

Všechny týmy registrované v jedné kategorii se přesunou do jiné zvolené kategorie. Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER].

    /joinCategory

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/teamRegistration/joinCategory?year=56&category=category_example&newCategory=newCategory_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
            String category = category_example; // String | Kategorie týmu, které se budou přesouvat do jiné
            String newCategory = newCategory_example; // String | Kategorie, do které se týmy přesunou

            try {
                inline_response_200_1 result = apiInstance.joinCategoryPut(year, category, newCategory);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#joinCategoryPut");
                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
            String category = category_example; // String | Kategorie týmu, které se budou přesouvat do jiné
            String newCategory = newCategory_example; // String | Kategorie, do které se týmy přesunou

            try {
                inline_response_200_1 result = apiInstance.joinCategoryPut(year, category, newCategory);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#joinCategoryPut");
                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)
    String *category = category_example; // Kategorie týmu, které se budou přesouvat do jiné (default to null)
    String *newCategory = newCategory_example; // Kategorie, do které se týmy přesunou (default to null)

    // Sloučí dvě různé kategorie dohromady
    [apiInstance joinCategoryPutWith:year
        category:category
        newCategory:newCategory
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamRegistrationApi = require('robo_cup_ms_team_registration_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamRegistrationApi.DefaultApi()
    var year = 56; // {Integer} Ročník soutěže
    var category = category_example; // {String} Kategorie týmu, které se budou přesouvat do jiné
    var newCategory = newCategory_example; // {String} Kategorie, do které se týmy přesunou

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

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

    namespace Example
    {
        public class joinCategoryPutExample
        {
            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 category = category_example;  // String | Kategorie týmu, které se budou přesouvat do jiné (default to null)
                var newCategory = newCategory_example;  // String | Kategorie, do které se týmy přesunou (default to null)

                try {
                    // Sloučí dvě různé kategorie dohromady
                    inline_response_200_1 result = apiInstance.joinCategoryPut(year, category, newCategory);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.joinCategoryPut: " + 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
    $category = category_example; // String | Kategorie týmu, které se budou přesouvat do jiné
    $newCategory = newCategory_example; // String | Kategorie, do které se týmy přesunou

    try {
        $result = $api_instance->joinCategoryPut($year, $category, $newCategory);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->joinCategoryPut: ', $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 $category = category_example; # String | Kategorie týmu, které se budou přesouvat do jiné
    my $newCategory = newCategory_example; # String | Kategorie, do které se týmy přesunou

    eval {
        my $result = $api_instance->joinCategoryPut(year => $year, category => $category, newCategory => $newCategory);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->joinCategoryPut: $@\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)
    category = category_example # String | Kategorie týmu, které se budou přesouvat do jiné (default to null)
    newCategory = newCategory_example # String | Kategorie, do které se týmy přesunou (default to null)

    try:
        # Sloučí dvě různé kategorie dohromady
        api_response = api_instance.join_category_put(year, category, newCategory)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->joinCategoryPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let year = 56; // Integer
        let category = category_example; // String
        let newCategory = newCategory_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročník soutěže Required
category* | String Kategorie týmu, které se budou přesouvat do jiné Required
newCategory* | String Kategorie, do které se týmy přesunou Required

## Responses

###

# registerPost

Registruje tým do soutěže

Registrovat tým může pouze vedoucí týmu. System automaticky přiřadí tým do kategorie (podle věku členů týmu). Kategorie je volena podle nejstaršího člena týmu. Registrovat tým je možne jen v případě, že daný ročník soutěže ještě nezačal.

    /register

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/api/teamRegistration/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();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200_1 result = apiInstance.registerPost(inlineObject);
                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();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200_1 result = apiInstance.registerPost(inlineObject);
                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];
    InlineObject *inlineObject = ; //

    // Registruje tým do soutěže
    [apiInstance registerPostWith:inlineObject
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamRegistrationApi = require('robo_cup_ms_team_registration_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamRegistrationApi.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.registerPost(inlineObject, 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 inlineObject = new InlineObject(); // InlineObject |

                try {
                    // Registruje tým do soutěže
                    inline_response_200_1 result = apiInstance.registerPost(inlineObject);
                    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();
    $inlineObject = ; // InlineObject |

    try {
        $result = $api_instance->registerPost($inlineObject);
        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 $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject |

    eval {
        my $result = $api_instance->registerPost(inlineObject => $inlineObject);
        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()
    inlineObject =  # InlineObject |

    try:
        # Registruje tým do soutěže
        api_response = api_instance.register_post(inlineObject)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->registerPost: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Body parameters

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

## Responses

###

# unregisterDelete

Zruší registraci týmu

Zrušit registraci tým může pouze vedoucí týmu. Zrušení nebude možne v případě, že soutěž již začala.

    /unregister

### Usage and SDK Samples

    curl -X DELETE \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/teamRegistration/unregister?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čník soutěže, pro který tým ruší registraci

            try {
                inline_response_200_1 result = apiInstance.unregisterDelete(year);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#unregisterDelete");
                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, pro který tým ruší registraci

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *year = 56; // Ročník soutěže, pro který tým ruší registraci (default to null)

    // Zruší registraci týmu
    [apiInstance unregisterDeleteWith:year
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamRegistrationApi = require('robo_cup_ms_team_registration_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamRegistrationApi.DefaultApi()
    var year = 56; // {Integer} Ročník soutěže, pro který tým ruší registraci

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var year = 56;  // Integer | Ročník soutěže, pro který tým ruší registraci (default to null)

                try {
                    // Zruší registraci týmu
                    inline_response_200_1 result = apiInstance.unregisterDelete(year);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.unregisterDelete: " + 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, pro který tým ruší registraci

    try {
        $result = $api_instance->unregisterDelete($year);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->unregisterDelete: ', $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, pro který tým ruší registraci

    eval {
        my $result = $api_instance->unregisterDelete(year => $year);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->unregisterDelete: $@\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, pro který tým ruší registraci (default to null)

    try:
        # Zruší registraci týmu
        api_response = api_instance.unregister_delete(year)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->unregisterDelete: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
year* | Integer Ročník soutěže, pro který tým ruší registraci Required

## Responses

###