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

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

public class ECTSApiExample {

    public static void main(String[] args) {
        
        ECTSApi apiInstance = new ECTSApi();
        ECTSResource body = ; // ECTSResource | 
        String edition = edition_example; // String | Edition which user wants to know how many ECTS he/she earned
        String identity = identity_example; // String | Personal ID used by the user when the ticket was created
        try {
            PostSuccessResource result = apiInstance.getECTS(body, edition, identity);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECTSApi#getECTS");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ECTSApi;

public class ECTSApiExample {

    public static void main(String[] args) {
        ECTSApi apiInstance = new ECTSApi();
        ECTSResource body = ; // ECTSResource | 
        String edition = edition_example; // String | Edition which user wants to know how many ECTS he/she earned
        String identity = identity_example; // String | Personal ID used by the user when the ticket was created
        try {
            PostSuccessResource result = apiInstance.getECTS(body, edition, identity);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECTSApi#getECTS");
            e.printStackTrace();
        }
    }
}

ECTSResource *body = ; // 
String *edition = edition_example; // Edition which user wants to know how many ECTS he/she earned
String *identity = identity_example; // Personal ID used by the user when the ticket was created

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

// Check the number of ECTS earned in all the editions of the congress.
[apiInstance getECTSWith:body
    edition:edition
    identity:identity
              completionHandler: ^(PostSuccessResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.ECTSApi()
var body = ; // {{ECTSResource}} 
var edition = edition_example; // {{String}} Edition which user wants to know how many ECTS he/she earned
var identity = identity_example; // {{String}} Personal ID used by the user when the ticket was created

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

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

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

            var apiInstance = new ECTSApi();
            var body = new ECTSResource(); // ECTSResource | 
            var edition = edition_example;  // String | Edition which user wants to know how many ECTS he/she earned
            var identity = identity_example;  // String | Personal ID used by the user when the ticket was created

            try
            {
                // Check the number of ECTS earned in all the editions of the congress.
                PostSuccessResource result = apiInstance.getECTS(body, edition, identity);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECTSApi.getECTS: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiECTSApi();
$body = ; // ECTSResource | 
$edition = edition_example; // String | Edition which user wants to know how many ECTS he/she earned
$identity = identity_example; // String | Personal ID used by the user when the ticket was created

try {
    $result = $api_instance->getECTS($body, $edition, $identity);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ECTSApi->getECTS: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ECTSApi->new();
my $body = WWW::SwaggerClient::Object::ECTSResource->new(); # ECTSResource | 
my $edition = edition_example; # String | Edition which user wants to know how many ECTS he/she earned
my $identity = identity_example; # String | Personal ID used by the user when the ticket was created

eval { 
    my $result = $api_instance->getECTS(body => $body, edition => $edition, identity => $identity);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ECTSApi->getECTS: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ECTSApi()
body =  # ECTSResource | 
edition = edition_example # String | Edition which user wants to know how many ECTS he/she earned
identity = identity_example # String | Personal ID used by the user when the ticket was created

try: 
    # Check the number of ECTS earned in all the editions of the congress.
    api_response = api_instance.get_ects(body, edition, identity)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ECTSApi->getECTS: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[BreakResource] result = apiInstance.getBreaks(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getBreaks");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[BreakResource] result = apiInstance.getBreaks(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getBreaks");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition

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

// Returns a JSON object with all the breaks scheduled
[apiInstance getBreaksWith:year
              completionHandler: ^(array[BreakResource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition

            try
            {
                // Returns a JSON object with all the breaks scheduled
                array[BreakResource] result = apiInstance.getBreaks(year);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getBreaks: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition

try: 
    # Returns a JSON object with all the breaks scheduled
    api_response = api_instance.get_breaks(year)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getBreaks: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        try {
            EditionsResource result = apiInstance.getEditions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEditions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        try {
            EditionsResource result = apiInstance.getEditions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEditions");
            e.printStackTrace();
        }
    }
}

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

// Returns a JSON object with all editions
[apiInstance getEditionsWithCompletionHandler: 
              ^(EditionsResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

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

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

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

            var apiInstance = new EditionsApi();

            try
            {
                // Returns a JSON object with all editions
                EditionsResource result = apiInstance.getEditions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getEditions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()

try: 
    # Returns a JSON object with all editions
    api_response = api_instance.get_editions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getEditions: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        Integer id = 56; // Integer | Id of the event
        try {
            EventGetResource result = apiInstance.getEvent(year, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        Integer id = 56; // Integer | Id of the event
        try {
            EventGetResource result = apiInstance.getEvent(year, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEvent");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition
Integer *id = 56; // Id of the event

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

// Returns the information and the list of available sessions for the given session
[apiInstance getEventWith:year
    id:id
              completionHandler: ^(EventGetResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition
var id = 56; // {{Integer}} Id of the event

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition
            var id = 56;  // Integer | Id of the event

            try
            {
                // Returns the information and the list of available sessions for the given session
                EventGetResource result = apiInstance.getEvent(year, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition
$id = 56; // Integer | Id of the event

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition
my $id = 56; # Integer | Id of the event

eval { 
    my $result = $api_instance->getEvent(year => $year, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EditionsApi->getEvent: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition
id = 56 # Integer | Id of the event

try: 
    # Returns the information and the list of available sessions for the given session
    api_response = api_instance.get_event(year, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getEvent: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            EventsResource result = apiInstance.getEvents(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            EventsResource result = apiInstance.getEvents(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getEvents");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition

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

// Returns the list of all the events in the given year
[apiInstance getEventsWith:year
              completionHandler: ^(EventsResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition

            try
            {
                // Returns the list of all the events in the given year
                EventsResource result = apiInstance.getEvents(year);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition

try: 
    # Returns the list of all the events in the given year
    api_response = api_instance.get_events(year)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getEvents: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[OrganizerResource] result = apiInstance.getOrganizers(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getOrganizers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[OrganizerResource] result = apiInstance.getOrganizers(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getOrganizers");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition

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

// Returns the list of all the organizers
[apiInstance getOrganizersWith:year
              completionHandler: ^(array[OrganizerResource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition

            try
            {
                // Returns the list of all the organizers
                array[OrganizerResource] result = apiInstance.getOrganizers(year);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getOrganizers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition

try: 
    # Returns the list of all the organizers
    api_response = api_instance.get_organizers(year)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getOrganizers: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[TalkResource] result = apiInstance.getTalks(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getTalks");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[TalkResource] result = apiInstance.getTalks(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getTalks");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition

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

// Returns a JSON object with all the talks
[apiInstance getTalksWith:year
              completionHandler: ^(array[TalkResource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition

            try
            {
                // Returns a JSON object with all the talks
                array[TalkResource] result = apiInstance.getTalks(year);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getTalks: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition

try: 
    # Returns a JSON object with all the talks
    api_response = api_instance.get_talks(year)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getTalks: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[WorkshopResource] result = apiInstance.getWorkshops(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getWorkshops");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        Integer year = 56; // Integer | Year of the edition
        try {
            array[WorkshopResource] result = apiInstance.getWorkshops(year);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#getWorkshops");
            e.printStackTrace();
        }
    }
}

Integer *year = 56; // Year of the edition

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

// Returns a JSON object with all the workshops
[apiInstance getWorkshopsWith:year
              completionHandler: ^(array[WorkshopResource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var year = 56; // {{Integer}} Year of the edition

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

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

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

            var apiInstance = new EditionsApi();
            var year = 56;  // Integer | Year of the edition

            try
            {
                // Returns a JSON object with all the workshops
                array[WorkshopResource] result = apiInstance.getWorkshops(year);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.getWorkshops: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$year = 56; // Integer | Year of the edition

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

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $year = 56; # Integer | Year of the edition

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

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
year = 56 # Integer | Year of the edition

try: 
    # Returns a JSON object with all the workshops
    api_response = api_instance.get_workshops(year)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->getWorkshops: %s\n" % e)

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

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

public class EditionsApiExample {

    public static void main(String[] args) {
        
        EditionsApi apiInstance = new EditionsApi();
        EventPostResource body = ; // EventPostResource | 
        Integer year = 56; // Integer | Year of the edition
        Integer id = 56; // Integer | Id of the event
        try {
            PostSuccessResource result = apiInstance.postEvent(body, year, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#postEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EditionsApi;

public class EditionsApiExample {

    public static void main(String[] args) {
        EditionsApi apiInstance = new EditionsApi();
        EventPostResource body = ; // EventPostResource | 
        Integer year = 56; // Integer | Year of the edition
        Integer id = 56; // Integer | Id of the event
        try {
            PostSuccessResource result = apiInstance.postEvent(body, year, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EditionsApi#postEvent");
            e.printStackTrace();
        }
    }
}

EventPostResource *body = ; // 
Integer *year = 56; // Year of the edition
Integer *id = 56; // Id of the event

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

// Register a user to one of the sessions for the Events
[apiInstance postEventWith:body
    year:year
    id:id
              completionHandler: ^(PostSuccessResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.EditionsApi()
var body = ; // {{EventPostResource}} 
var year = 56; // {{Integer}} Year of the edition
var id = 56; // {{Integer}} Id of the event

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

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

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

            var apiInstance = new EditionsApi();
            var body = new EventPostResource(); // EventPostResource | 
            var year = 56;  // Integer | Year of the edition
            var id = 56;  // Integer | Id of the event

            try
            {
                // Register a user to one of the sessions for the Events
                PostSuccessResource result = apiInstance.postEvent(body, year, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EditionsApi.postEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEditionsApi();
$body = ; // EventPostResource | 
$year = 56; // Integer | Year of the edition
$id = 56; // Integer | Id of the event

try {
    $result = $api_instance->postEvent($body, $year, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EditionsApi->postEvent: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EditionsApi->new();
my $body = WWW::SwaggerClient::Object::EventPostResource->new(); # EventPostResource | 
my $year = 56; # Integer | Year of the edition
my $id = 56; # Integer | Id of the event

eval { 
    my $result = $api_instance->postEvent(body => $body, year => $year, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EditionsApi->postEvent: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EditionsApi()
body =  # EventPostResource | 
year = 56 # Integer | Year of the edition
id = 56 # Integer | Id of the event

try: 
    # Register a user to one of the sessions for the Events
    api_response = api_instance.post_event(body, year, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EditionsApi->postEvent: %s\n" % e)

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

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

public class HomeApiExample {

    public static void main(String[] args) {
        
        HomeApi apiInstance = new HomeApi();
        try {
            SponsorsResource result = apiInstance.getSponsors();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HomeApi#getSponsors");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HomeApi;

public class HomeApiExample {

    public static void main(String[] args) {
        HomeApi apiInstance = new HomeApi();
        try {
            SponsorsResource result = apiInstance.getSponsors();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HomeApi#getSponsors");
            e.printStackTrace();
        }
    }
}

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

// Returns a JSON object with all the sponsors for the last edition
[apiInstance getSponsorsWithCompletionHandler: 
              ^(SponsorsResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

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

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

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

            var apiInstance = new HomeApi();

            try
            {
                // Returns a JSON object with all the sponsors for the last edition
                SponsorsResource result = apiInstance.getSponsors();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HomeApi.getSponsors: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiHomeApi();

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

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

my $api_instance = WWW::SwaggerClient::HomeApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.HomeApi()

try: 
    # Returns a JSON object with all the sponsors for the last edition
    api_response = api_instance.get_sponsors()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HomeApi->getSponsors: %s\n" % e)

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

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

public class HomeApiExample {

    public static void main(String[] args) {
        
        HomeApi apiInstance = new HomeApi();
        try {
            StreamingResource result = apiInstance.getStreaming();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HomeApi#getStreaming");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HomeApi;

public class HomeApiExample {

    public static void main(String[] args) {
        HomeApi apiInstance = new HomeApi();
        try {
            StreamingResource result = apiInstance.getStreaming();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HomeApi#getStreaming");
            e.printStackTrace();
        }
    }
}

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

// Returns a JSON object with the streaming information
[apiInstance getStreamingWithCompletionHandler: 
              ^(StreamingResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

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

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

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

            var apiInstance = new HomeApi();

            try
            {
                // Returns a JSON object with the streaming information
                StreamingResource result = apiInstance.getStreaming();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HomeApi.getStreaming: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiHomeApi();

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

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

my $api_instance = WWW::SwaggerClient::HomeApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.HomeApi()

try: 
    # Returns a JSON object with the streaming information
    api_response = api_instance.get_streaming()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HomeApi->getStreaming: %s\n" % e)

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

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

public class TicketsApiExample {

    public static void main(String[] args) {
        
        TicketsApi apiInstance = new TicketsApi();
        TicketResource body = ; // TicketResource | 
        try {
            PostSuccessResource result = apiInstance.postTicket(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#postTicket");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TicketsApi;

public class TicketsApiExample {

    public static void main(String[] args) {
        TicketsApi apiInstance = new TicketsApi();
        TicketResource body = ; // TicketResource | 
        try {
            PostSuccessResource result = apiInstance.postTicket(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#postTicket");
            e.printStackTrace();
        }
    }
}

TicketResource *body = ; // 

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

// Creates a new ticket
[apiInstance postTicketWith:body
              completionHandler: ^(PostSuccessResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.TicketsApi()
var body = ; // {{TicketResource}} 

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

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

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

            var apiInstance = new TicketsApi();
            var body = new TicketResource(); // TicketResource | 

            try
            {
                // Creates a new ticket
                PostSuccessResource result = apiInstance.postTicket(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TicketsApi.postTicket: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTicketsApi();
$body = ; // TicketResource | 

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

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

my $api_instance = WWW::SwaggerClient::TicketsApi->new();
my $body = WWW::SwaggerClient::Object::TicketResource->new(); # TicketResource | 

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

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

# create an instance of the API class
api_instance = swagger_client.TicketsApi()
body =  # TicketResource | 

try: 
    # Creates a new ticket
    api_response = api_instance.post_ticket(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->postTicket: %s\n" % e)

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

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

public class ValidateApiExample {

    public static void main(String[] args) {
        
        ValidateApi apiInstance = new ValidateApi();
        ValidationResource body = ; // ValidationResource | 
        try {
            PostSuccessResource result = apiInstance.postValidation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ValidateApi#postValidation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ValidateApi;

public class ValidateApiExample {

    public static void main(String[] args) {
        ValidateApi apiInstance = new ValidateApi();
        ValidationResource body = ; // ValidationResource | 
        try {
            PostSuccessResource result = apiInstance.postValidation(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ValidateApi#postValidation");
            e.printStackTrace();
        }
    }
}

ValidationResource *body = ; // 

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

// Sends the information in order to validate tickets
[apiInstance postValidationWith:body
              completionHandler: ^(PostSuccessResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.ValidateApi()
var body = ; // {{ValidationResource}} 

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

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

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

            var apiInstance = new ValidateApi();
            var body = new ValidationResource(); // ValidationResource | 

            try
            {
                // Sends the information in order to validate tickets
                PostSuccessResource result = apiInstance.postValidation(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ValidateApi.postValidation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiValidateApi();
$body = ; // ValidationResource | 

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

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

my $api_instance = WWW::SwaggerClient::ValidateApi->new();
my $body = WWW::SwaggerClient::Object::ValidationResource->new(); # ValidationResource | 

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

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

# create an instance of the API class
api_instance = swagger_client.ValidateApi()
body =  # ValidationResource | 

try: 
    # Sends the information in order to validate tickets
    api_response = api_instance.post_validation(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ValidateApi->postValidation: %s\n" % e)

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

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

public class VolunteersApiExample {

    public static void main(String[] args) {
        
        VolunteersApi apiInstance = new VolunteersApi();
        try {
            array[VolunteerPeriodsResource] result = apiInstance.getVolunteer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VolunteersApi#getVolunteer");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VolunteersApi;

public class VolunteersApiExample {

    public static void main(String[] args) {
        VolunteersApi apiInstance = new VolunteersApi();
        try {
            array[VolunteerPeriodsResource] result = apiInstance.getVolunteer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VolunteersApi#getVolunteer");
            e.printStackTrace();
        }
    }
}

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

// Obtains the time periods available for the volunteers.
[apiInstance getVolunteerWithCompletionHandler: 
              ^(array[VolunteerPeriodsResource] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

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

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

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

            var apiInstance = new VolunteersApi();

            try
            {
                // Obtains the time periods available for the volunteers.
                array[VolunteerPeriodsResource] result = apiInstance.getVolunteer();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VolunteersApi.getVolunteer: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiVolunteersApi();

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

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

my $api_instance = WWW::SwaggerClient::VolunteersApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.VolunteersApi()

try: 
    # Obtains the time periods available for the volunteers.
    api_response = api_instance.get_volunteer()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VolunteersApi->getVolunteer: %s\n" % e)

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

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

public class VolunteersApiExample {

    public static void main(String[] args) {
        
        VolunteersApi apiInstance = new VolunteersApi();
        VolunteerResource body = ; // VolunteerResource | 
        try {
            PostSuccessResource result = apiInstance.postVolunteer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VolunteersApi#postVolunteer");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.VolunteersApi;

public class VolunteersApiExample {

    public static void main(String[] args) {
        VolunteersApi apiInstance = new VolunteersApi();
        VolunteerResource body = ; // VolunteerResource | 
        try {
            PostSuccessResource result = apiInstance.postVolunteer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VolunteersApi#postVolunteer");
            e.printStackTrace();
        }
    }
}

VolunteerResource *body = ; // 

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

// Creates a new volunteer
[apiInstance postVolunteerWith:body
              completionHandler: ^(PostSuccessResource output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TryItApi = require('try_it_api');

var api = new TryItApi.VolunteersApi()
var body = ; // {{VolunteerResource}} 

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

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

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

            var apiInstance = new VolunteersApi();
            var body = new VolunteerResource(); // VolunteerResource | 

            try
            {
                // Creates a new volunteer
                PostSuccessResource result = apiInstance.postVolunteer(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling VolunteersApi.postVolunteer: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiVolunteersApi();
$body = ; // VolunteerResource | 

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

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

my $api_instance = WWW::SwaggerClient::VolunteersApi->new();
my $body = WWW::SwaggerClient::Object::VolunteerResource->new(); # VolunteerResource | 

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

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

# create an instance of the API class
api_instance = swagger_client.VolunteersApi()
body =  # VolunteerResource | 

try: 
    # Creates a new volunteer
    api_response = api_instance.post_volunteer(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VolunteersApi->postVolunteer: %s\n" % e)