# RoboCupMS - Team API

## API and SDK Documentation

Version: 2.0.0

API sloužící pro správu týmů na serveru. Jednotlivé týmy se pak přihlašuji do konkrétních ročníků soutěže.

# Default

# addMemberPut

Přidá nového člena do týmu

Přidat nového člena může jen vedoucí týmu. Uživatel bude přidán jen pokud nebude v žádném týmu.

    /addMember

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/addMember?uuid=38400000-8cf0-11bd-b23e-10b96e4ef00d"

    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();
            UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    UUID *uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID uživatele (default to null)

    // Přidá nového člena do týmu
    [apiInstance addMemberPutWith:uuid
                  completionHandler: ^(inline_response_200_3 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID uživatele (default to null)

                try {
                    // Přidá nového člena do týmu
                    inline_response_200_3 result = apiInstance.addMemberPut(uuid);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.addMemberPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

    try {
        $result = $api_instance->addMemberPut($uuid);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->addMemberPut: ', $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 $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID uživatele

    eval {
        my $result = $api_instance->addMemberPut(uuid => $uuid);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->addMemberPut: $@\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()
    uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID uživatele (default to null)

    try:
        # Přidá nového člena do týmu
        api_response = api_instance.add_member_put(uuid)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->addMemberPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
uuid* | UUID (uuid) UUID uživatele Required

## Responses

###

# allGet

Navrátí vsechný týmy, kterou jsou v systému vytvořeny

    /all

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/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_2 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_2 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í vsechný týmy, kterou jsou v systému vytvořeny
    [apiInstance allGetWithCompletionHandler:
                  ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.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í vsechný týmy, kterou jsou v systému vytvořeny
                    inline_response_200_2 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í vsechný týmy, kterou jsou v systému vytvořeny
        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

###

# createPost

Vytvoří nový tým

Uživatel, který vytváří tým se stává jeho vedoucím. Uživatel může byt jen v jednom tým. Tým muže vytvořit jen v případě, že se v žádnem nenachází.

    /create

### Usage and SDK Samples

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

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

    // Vytvoří nový tým
    [apiInstance createPostWith:inlineObject
                  completionHandler: ^(inline_response_200_3 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

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

                try {
                    // Vytvoří nový tým
                    inline_response_200_3 result = apiInstance.createPost(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();
    $inlineObject = ; // InlineObject |

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

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

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Body parameters

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

## Responses

###

# findByIDGet

Navrátí informace o týmu s konkrétním ID

    /findByID

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/findByID?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 týmu

            try {
                inline_response_200_1 result = apiInstance.findByIDGet(id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#findByIDGet");
                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

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

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

    // Navrátí informace o týmu s konkrétním ID
    [apiInstance findByIDGetWith:id
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var id = 56; // {Integer} ID týmu

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

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

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

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

                try {
                    // Navrátí informace o týmu s konkrétním ID
                    inline_response_200_1 result = apiInstance.findByIDGet(id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.findByIDGet: " + 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

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

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

    try:
        # Navrátí informace o týmu s konkrétním ID
        api_response = api_instance.find_by_id_get(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->findByIDGet: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID týmu Required

## Responses

###

# findByNameGet

Navrátí informace o týmu s konkrétním jménem

    /findByName

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/findByName?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();
            String name = name_example; // String | Jméno týmu

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String name = name_example; // String | Jméno týmu

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *name = name_example; // Jméno týmu (default to null)

    // Navrátí informace o týmu s konkrétním jménem
    [apiInstance findByNameGetWith:name
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var name = name_example; // {String} Jméno týmu

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var name = name_example;  // String | Jméno týmu (default to null)

                try {
                    // Navrátí informace o týmu s konkrétním jménem
                    inline_response_200_1 result = apiInstance.findByNameGet(name);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.findByNameGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $name = name_example; // String | Jméno týmu

    try {
        $result = $api_instance->findByNameGet($name);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->findByNameGet: ', $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 $name = name_example; # String | Jméno týmu

    eval {
        my $result = $api_instance->findByNameGet(name => $name);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->findByNameGet: $@\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()
    name = name_example # String | Jméno týmu (default to null)

    try:
        # Navrátí informace o týmu s konkrétním jménem
        api_response = api_instance.find_by_name_get(name)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->findByNameGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let name = name_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
name* | String Jméno týmu Required

## Responses

###

# leavePut

Opusti tým, ve kterém se přihlášený uživatel nachází. Nový vedoucí je určen v případě kdy tým opouští jeho vedoucí.

    /leave

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/leave"

    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_3 result = apiInstance.leavePut();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#leavePut");
                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_3 result = apiInstance.leavePut();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#leavePut");
                e.printStackTrace();
            }
        }
    }

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

    // Opusti tým, ve kterém se přihlášený uživatel nachází. Nový vedoucí je určen v případě kdy tým opouští jeho vedoucí.
    [apiInstance leavePutWithCompletionHandler:
                  ^(inline_response_200_3 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

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

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

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

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

                try {
                    // Opusti tým, ve kterém se přihlášený uživatel nachází. Nový vedoucí je určen v případě kdy tým opouští jeho vedoucí.
                    inline_response_200_3 result = apiInstance.leavePut();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.leavePut: " + 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->leavePut();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->leavePut: ', $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->leavePut();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->leavePut: $@\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:
        # Opusti tým, ve kterém se přihlášený uživatel nachází. Nový vedoucí je určen v případě kdy tým opouští jeho vedoucí.
        api_response = api_instance.leave_put()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->leavePut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

# myTeamGet

Navrátí informace o týmu, ve kterém se přihlášený uživatel nachází

    /myTeam

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/myTeam"

    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.myTeamGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#myTeamGet");
                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.myTeamGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#myTeamGet");
                e.printStackTrace();
            }
        }
    }

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

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

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

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

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

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

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

                try {
                    // Navrátí informace o týmu, ve kterém se přihlášený uživatel nachází
                    inline_response_200 result = apiInstance.myTeamGet();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.myTeamGet: " + 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->myTeamGet();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->myTeamGet: ', $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->myTeamGet();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->myTeamGet: $@\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í informace o týmu, ve kterém se přihlášený uživatel nachází
        api_response = api_instance.my_team_get()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->myTeamGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

# removeDelete

Odstraní tým

Tým může odstránit jen jeho vedoucí a to s tou podmínkou, že není registrovaný v soutěži, která jit začala.

    /remove

### Usage and SDK Samples

    curl -X DELETE \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/remove?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();
            String name = name_example; // String | Jméno týmu

            try {
                inline_response_200_3 result = apiInstance.removeDelete(name);
                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();
            String name = name_example; // String | Jméno týmu

            try {
                inline_response_200_3 result = apiInstance.removeDelete(name);
                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];
    String *name = name_example; // Jméno týmu (default to null)

    // Odstraní tým
    [apiInstance removeDeleteWith:name
                  completionHandler: ^(inline_response_200_3 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var name = name_example; // {String} Jméno týmu

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.removeDelete(name, 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 name = name_example;  // String | Jméno týmu (default to null)

                try {
                    // Odstraní tým
                    inline_response_200_3 result = apiInstance.removeDelete(name);
                    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();
    $name = name_example; // String | Jméno týmu

    try {
        $result = $api_instance->removeDelete($name);
        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 $name = name_example; # String | Jméno týmu

    eval {
        my $result = $api_instance->removeDelete(name => $name);
        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()
    name = name_example # String | Jméno týmu (default to null)

    try:
        # Odstraní tým
        api_response = api_instance.remove_delete(name)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->removeDelete: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let name = name_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
name* | String Jméno týmu Required

## Responses

###

# removeMemberPut

Odebere člena z týmu

Odebrat člena týmu může jen vedoucí týmu.

    /removeMember

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/removeMember?uuid=38400000-8cf0-11bd-b23e-10b96e4ef00d"

    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();
            UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    UUID *uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID uživatele (default to null)

    // Odebere člena z týmu
    [apiInstance removeMemberPutWith:uuid
                  completionHandler: ^(inline_response_200_3 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID uživatele (default to null)

                try {
                    // Odebere člena z týmu
                    inline_response_200_3 result = apiInstance.removeMemberPut(uuid);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.removeMemberPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID uživatele

    try {
        $result = $api_instance->removeMemberPut($uuid);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->removeMemberPut: ', $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 $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID uživatele

    eval {
        my $result = $api_instance->removeMemberPut(uuid => $uuid);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->removeMemberPut: $@\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()
    uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID uživatele (default to null)

    try:
        # Odebere člena z týmu
        api_response = api_instance.remove_member_put(uuid)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->removeMemberPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
uuid* | UUID (uuid) UUID uživatele Required

## Responses

###

# renamePut

Změní jméno týmu

Přejmenovat tým může jen jeho vedoucí

    /rename

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/team/rename?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();
            String name = name_example; // String | Nové jméno týmu (unikátní)

            try {
                inline_response_200_3 result = apiInstance.renamePut(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();
            String name = name_example; // String | Nové jméno týmu (unikátní)

            try {
                inline_response_200_3 result = apiInstance.renamePut(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];
    String *name = name_example; // Nové jméno týmu (unikátní) (default to null)

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

    var RoboCupMsTeamApi = require('robo_cup_ms_team_api');

    // Create an instance of the API class
    var api = new RoboCupMsTeamApi.DefaultApi()
    var name = name_example; // {String} Nové jméno týmu (unikátní)

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.renamePut(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 name = name_example;  // String | Nové jméno týmu (unikátní) (default to null)

                try {
                    // Změní jméno týmu
                    inline_response_200_3 result = apiInstance.renamePut(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();
    $name = name_example; // String | Nové jméno týmu (unikátní)

    try {
        $result = $api_instance->renamePut($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 $name = name_example; # String | Nové jméno týmu (unikátní)

    eval {
        my $result = $api_instance->renamePut(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()
    name = name_example # String | Nové jméno týmu (unikátní) (default to null)

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

    extern crate DefaultApi;

    pub fn main() {
        let name = name_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
name* | String Nové jméno týmu (unikátní) Required

## Responses

###