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

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

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventActivitiesApi apiInstance = new EventActivitiesApi();
        EventId_activityId_body_1 body = ; // EventId_activityId_body_1 | 
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityCheckinEventIdActivityIdPost(body, eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityCheckinEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventActivitiesApi;

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        EventActivitiesApi apiInstance = new EventActivitiesApi();
        EventId_activityId_body_1 body = ; // EventId_activityId_body_1 | 
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityCheckinEventIdActivityIdPost(body, eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityCheckinEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
EventId_activityId_body_1 *body = ; // 
String *eventId = eventId_example; // ID of the event
String *activityId = activityId_example; // ID of the activity

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

// Check-in user for an event activity
[apiInstance eventactivityCheckinEventIdActivityIdPostWith:body
    eventId:eventId
    activityId:activityId
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventActivitiesApi()
var body = ; // {{EventId_activityId_body_1}} 
var eventId = eventId_example; // {{String}} ID of the event
var activityId = activityId_example; // {{String}} ID of the activity

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

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

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


            var apiInstance = new EventActivitiesApi();
            var body = new EventId_activityId_body_1(); // EventId_activityId_body_1 | 
            var eventId = eventId_example;  // String | ID of the event
            var activityId = activityId_example;  // String | ID of the activity

            try
            {
                // Check-in user for an event activity
                inline_response_201 result = apiInstance.eventactivityCheckinEventIdActivityIdPost(body, eventId, activityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventActivitiesApi.eventactivityCheckinEventIdActivityIdPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventActivitiesApi();
$body = ; // EventId_activityId_body_1 | 
$eventId = eventId_example; // String | ID of the event
$activityId = activityId_example; // String | ID of the activity

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

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


my $api_instance = WWW::SwaggerClient::EventActivitiesApi->new();
my $body = WWW::SwaggerClient::Object::EventId_activityId_body_1->new(); # EventId_activityId_body_1 | 
my $eventId = eventId_example; # String | ID of the event
my $activityId = activityId_example; # String | ID of the activity

eval { 
    my $result = $api_instance->eventactivityCheckinEventIdActivityIdPost(body => $body, eventId => $eventId, activityId => $activityId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventActivitiesApi->eventactivityCheckinEventIdActivityIdPost: $@\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.EventActivitiesApi()
body =  # EventId_activityId_body_1 | 
eventId = eventId_example # String | ID of the event
activityId = activityId_example # String | ID of the activity

try: 
    # Check-in user for an event activity
    api_response = api_instance.eventactivity_checkin_event_id_activity_id_post(body, eventId, activityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventActivitiesApi->eventactivityCheckinEventIdActivityIdPost: %s\n" % e)

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

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

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventActivitiesApi apiInstance = new EventActivitiesApi();
        String eventId = eventId_example; // String | ID of the event
        String userId = userId_example; // String | ID of the user
        try {
            inline_response_200_1 result = apiInstance.eventactivityEventIdRegisteredActivitiesPost(eventId, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityEventIdRegisteredActivitiesPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventActivitiesApi;

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        EventActivitiesApi apiInstance = new EventActivitiesApi();
        String eventId = eventId_example; // String | ID of the event
        String userId = userId_example; // String | ID of the user
        try {
            inline_response_200_1 result = apiInstance.eventactivityEventIdRegisteredActivitiesPost(eventId, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityEventIdRegisteredActivitiesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *eventId = eventId_example; // ID of the event
String *userId = userId_example; // ID of the user

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

// Get activities for an event
[apiInstance eventactivityEventIdRegisteredActivitiesPostWith:eventId
    userId:userId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventActivitiesApi()
var eventId = eventId_example; // {{String}} ID of the event
var userId = userId_example; // {{String}} ID of the user

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

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

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


            var apiInstance = new EventActivitiesApi();
            var eventId = eventId_example;  // String | ID of the event
            var userId = userId_example;  // String | ID of the user

            try
            {
                // Get activities for an event
                inline_response_200_1 result = apiInstance.eventactivityEventIdRegisteredActivitiesPost(eventId, userId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventActivitiesApi.eventactivityEventIdRegisteredActivitiesPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventActivitiesApi();
$eventId = eventId_example; // String | ID of the event
$userId = userId_example; // String | ID of the user

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

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


my $api_instance = WWW::SwaggerClient::EventActivitiesApi->new();
my $eventId = eventId_example; # String | ID of the event
my $userId = userId_example; # String | ID of the user

eval { 
    my $result = $api_instance->eventactivityEventIdRegisteredActivitiesPost(eventId => $eventId, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventActivitiesApi->eventactivityEventIdRegisteredActivitiesPost: $@\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.EventActivitiesApi()
eventId = eventId_example # String | ID of the event
userId = userId_example # String | ID of the user

try: 
    # Get activities for an event
    api_response = api_instance.eventactivity_event_id_registered_activities_post(eventId, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventActivitiesApi->eventactivityEventIdRegisteredActivitiesPost: %s\n" % e)

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

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

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventActivitiesApi apiInstance = new EventActivitiesApi();
        EventId_activityId_body body = ; // EventId_activityId_body | 
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityRegisterEventIdActivityIdPost(body, eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityRegisterEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventActivitiesApi;

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        EventActivitiesApi apiInstance = new EventActivitiesApi();
        EventId_activityId_body body = ; // EventId_activityId_body | 
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityRegisterEventIdActivityIdPost(body, eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityRegisterEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
EventId_activityId_body *body = ; // 
String *eventId = eventId_example; // ID of the event
String *activityId = activityId_example; // ID of the activity

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

// Register user for an event activity
[apiInstance eventactivityRegisterEventIdActivityIdPostWith:body
    eventId:eventId
    activityId:activityId
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventActivitiesApi()
var body = ; // {{EventId_activityId_body}} 
var eventId = eventId_example; // {{String}} ID of the event
var activityId = activityId_example; // {{String}} ID of the activity

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

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

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


            var apiInstance = new EventActivitiesApi();
            var body = new EventId_activityId_body(); // EventId_activityId_body | 
            var eventId = eventId_example;  // String | ID of the event
            var activityId = activityId_example;  // String | ID of the activity

            try
            {
                // Register user for an event activity
                inline_response_201 result = apiInstance.eventactivityRegisterEventIdActivityIdPost(body, eventId, activityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventActivitiesApi.eventactivityRegisterEventIdActivityIdPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventActivitiesApi();
$body = ; // EventId_activityId_body | 
$eventId = eventId_example; // String | ID of the event
$activityId = activityId_example; // String | ID of the activity

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

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


my $api_instance = WWW::SwaggerClient::EventActivitiesApi->new();
my $body = WWW::SwaggerClient::Object::EventId_activityId_body->new(); # EventId_activityId_body | 
my $eventId = eventId_example; # String | ID of the event
my $activityId = activityId_example; # String | ID of the activity

eval { 
    my $result = $api_instance->eventactivityRegisterEventIdActivityIdPost(body => $body, eventId => $eventId, activityId => $activityId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventActivitiesApi->eventactivityRegisterEventIdActivityIdPost: $@\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.EventActivitiesApi()
body =  # EventId_activityId_body | 
eventId = eventId_example # String | ID of the event
activityId = activityId_example # String | ID of the activity

try: 
    # Register user for an event activity
    api_response = api_instance.eventactivity_register_event_id_activity_id_post(body, eventId, activityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventActivitiesApi->eventactivityRegisterEventIdActivityIdPost: %s\n" % e)

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

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

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventActivitiesApi apiInstance = new EventActivitiesApi();
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityUnregisterEventIdActivityIdPost(eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityUnregisterEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventActivitiesApi;

public class EventActivitiesApiExample {

    public static void main(String[] args) {
        EventActivitiesApi apiInstance = new EventActivitiesApi();
        String eventId = eventId_example; // String | ID of the event
        String activityId = activityId_example; // String | ID of the activity
        try {
            inline_response_201 result = apiInstance.eventactivityUnregisterEventIdActivityIdPost(eventId, activityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventActivitiesApi#eventactivityUnregisterEventIdActivityIdPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *eventId = eventId_example; // ID of the event
String *activityId = activityId_example; // ID of the activity

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

// Unregister user from an event activity
[apiInstance eventactivityUnregisterEventIdActivityIdPostWith:eventId
    activityId:activityId
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventActivitiesApi()
var eventId = eventId_example; // {{String}} ID of the event
var activityId = activityId_example; // {{String}} ID of the activity

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

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

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


            var apiInstance = new EventActivitiesApi();
            var eventId = eventId_example;  // String | ID of the event
            var activityId = activityId_example;  // String | ID of the activity

            try
            {
                // Unregister user from an event activity
                inline_response_201 result = apiInstance.eventactivityUnregisterEventIdActivityIdPost(eventId, activityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventActivitiesApi.eventactivityUnregisterEventIdActivityIdPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventActivitiesApi();
$eventId = eventId_example; // String | ID of the event
$activityId = activityId_example; // String | ID of the activity

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

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


my $api_instance = WWW::SwaggerClient::EventActivitiesApi->new();
my $eventId = eventId_example; # String | ID of the event
my $activityId = activityId_example; # String | ID of the activity

eval { 
    my $result = $api_instance->eventactivityUnregisterEventIdActivityIdPost(eventId => $eventId, activityId => $activityId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventActivitiesApi->eventactivityUnregisterEventIdActivityIdPost: $@\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.EventActivitiesApi()
eventId = eventId_example # String | ID of the event
activityId = activityId_example # String | ID of the activity

try: 
    # Unregister user from an event activity
    api_response = api_instance.eventactivity_unregister_event_id_activity_id_post(eventId, activityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventActivitiesApi->eventactivityUnregisterEventIdActivityIdPost: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        String eventId = eventId_example; // String | ID of the event to retrieve activities for
        try {
            inline_response_200_1 result = apiInstance.eventsEventIdActivitiesPost(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdActivitiesPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        String eventId = eventId_example; // String | ID of the event to retrieve activities for
        try {
            inline_response_200_1 result = apiInstance.eventsEventIdActivitiesPost(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdActivitiesPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *eventId = eventId_example; // ID of the event to retrieve activities for

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

// Get activities for an event
[apiInstance eventsEventIdActivitiesPostWith:eventId
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventsApi()
var eventId = eventId_example; // {{String}} ID of the event to retrieve activities for

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

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

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


            var apiInstance = new EventsApi();
            var eventId = eventId_example;  // String | ID of the event to retrieve activities for

            try
            {
                // Get activities for an event
                inline_response_200_1 result = apiInstance.eventsEventIdActivitiesPost(eventId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.eventsEventIdActivitiesPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventsApi();
$eventId = eventId_example; // String | ID of the event to retrieve activities for

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

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


my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $eventId = eventId_example; # String | ID of the event to retrieve activities for

eval { 
    my $result = $api_instance->eventsEventIdActivitiesPost(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->eventsEventIdActivitiesPost: $@\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.EventsApi()
eventId = eventId_example # String | ID of the event to retrieve activities for

try: 
    # Get activities for an event
    api_response = api_instance.events_event_id_activities_post(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->eventsEventIdActivitiesPost: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        EventId_createactivity_body body = ; // EventId_createactivity_body | 
        String eventId = eventId_example; // String | ID of the event to add the activity to
        try {
            inline_response_201_1 result = apiInstance.eventsEventIdCreateActivityPost(body, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdCreateActivityPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        EventId_createactivity_body body = ; // EventId_createactivity_body | 
        String eventId = eventId_example; // String | ID of the event to add the activity to
        try {
            inline_response_201_1 result = apiInstance.eventsEventIdCreateActivityPost(body, eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdCreateActivityPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
EventId_createactivity_body *body = ; // 
String *eventId = eventId_example; // ID of the event to add the activity to

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

// Create an activity for an event
[apiInstance eventsEventIdCreateActivityPostWith:body
    eventId:eventId
              completionHandler: ^(inline_response_201_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventsApi()
var body = ; // {{EventId_createactivity_body}} 
var eventId = eventId_example; // {{String}} ID of the event to add the activity to

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

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

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


            var apiInstance = new EventsApi();
            var body = new EventId_createactivity_body(); // EventId_createactivity_body | 
            var eventId = eventId_example;  // String | ID of the event to add the activity to

            try
            {
                // Create an activity for an event
                inline_response_201_1 result = apiInstance.eventsEventIdCreateActivityPost(body, eventId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.eventsEventIdCreateActivityPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventsApi();
$body = ; // EventId_createactivity_body | 
$eventId = eventId_example; // String | ID of the event to add the activity to

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

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


my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $body = WWW::SwaggerClient::Object::EventId_createactivity_body->new(); # EventId_createactivity_body | 
my $eventId = eventId_example; # String | ID of the event to add the activity to

eval { 
    my $result = $api_instance->eventsEventIdCreateActivityPost(body => $body, eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->eventsEventIdCreateActivityPost: $@\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.EventsApi()
body =  # EventId_createactivity_body | 
eventId = eventId_example # String | ID of the event to add the activity to

try: 
    # Create an activity for an event
    api_response = api_instance.events_event_id_create_activity_post(body, eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->eventsEventIdCreateActivityPost: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        String eventId = eventId_example; // String | ID of the event to retrieve
        try {
            Event result = apiInstance.eventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

    public static void main(String[] args) {
        EventsApi apiInstance = new EventsApi();
        String eventId = eventId_example; // String | ID of the event to retrieve
        try {
            Event result = apiInstance.eventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsEventIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *eventId = eventId_example; // ID of the event to retrieve

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

// Get an event by ID
[apiInstance eventsEventIdGetWith:eventId
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.EventsApi()
var eventId = eventId_example; // {{String}} ID of the event to retrieve

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

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

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


            var apiInstance = new EventsApi();
            var eventId = eventId_example;  // String | ID of the event to retrieve

            try
            {
                // Get an event by ID
                Event result = apiInstance.eventsEventIdGet(eventId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.eventsEventIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiEventsApi();
$eventId = eventId_example; // String | ID of the event to retrieve

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

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


my $api_instance = WWW::SwaggerClient::EventsApi->new();
my $eventId = eventId_example; # String | ID of the event to retrieve

eval { 
    my $result = $api_instance->eventsEventIdGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsApi->eventsEventIdGet: $@\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.EventsApi()
eventId = eventId_example # String | ID of the event to retrieve

try: 
    # Get an event by ID
    api_response = api_instance.events_event_id_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->eventsEventIdGet: %s\n" % e)

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

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

public class EventsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        EventsApi apiInstance = new EventsApi();
        try {
            array[Event] result = apiInstance.eventsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#eventsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventsApi;

public class EventsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get all events
[apiInstance eventsGetWithCompletionHandler: 
              ^(array[Event] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


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

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

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


            var apiInstance = new EventsApi();

            try
            {
                // Get all events
                array[Event] result = apiInstance.eventsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventsApi.eventsGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

try: 
    # Get all events
    api_response = api_instance.events_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsApi->eventsGet: %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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        TicketsApi apiInstance = new TicketsApi();
        Todos_buy_body body = ; // Todos_buy_body | 
        try {
            apiInstance.todosBuyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#todosBuyPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TicketsApi;

public class TicketsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Todos_buy_body *body = ; // 

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

// Buy event tickets
[apiInstance todosBuyPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.TicketsApi()
var body = ; // {{Todos_buy_body}} 

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

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

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


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

            try
            {
                // Buy event tickets
                apiInstance.todosBuyPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TicketsApi.todosBuyPost: " + e.Message );
            }
        }
    }
}

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


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

try {
    $api_instance->todosBuyPost($body);
} catch (Exception $e) {
    echo 'Exception when calling TicketsApi->todosBuyPost: ', $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::Todos_buy_body->new(); # Todos_buy_body | 

eval { 
    $api_instance->todosBuyPost(body => $body);
};
if ($@) {
    warn "Exception when calling TicketsApi->todosBuyPost: $@\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 =  # Todos_buy_body | 

try: 
    # Buy event tickets
    api_instance.todos_buy_post(body)
except ApiException as e:
    print("Exception when calling TicketsApi->todosBuyPost: %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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        TicketsApi apiInstance = new TicketsApi();
        Todos_mytickets_body body = ; // Todos_mytickets_body | 
        try {
            array[Event] result = apiInstance.todosMyticketsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#todosMyticketsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TicketsApi;

public class TicketsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Todos_mytickets_body *body = ; // 

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

// Get user tickets
[apiInstance todosMyticketsPostWith:body
              completionHandler: ^(array[Event] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.TicketsApi()
var body = ; // {{Todos_mytickets_body}} 

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

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

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


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

            try
            {
                // Get user tickets
                array[Event] result = apiInstance.todosMyticketsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TicketsApi.todosMyticketsPost: " + e.Message );
            }
        }
    }
}

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


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

try {
    $result = $api_instance->todosMyticketsPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TicketsApi->todosMyticketsPost: ', $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::Todos_mytickets_body->new(); # Todos_mytickets_body | 

eval { 
    my $result = $api_instance->todosMyticketsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketsApi->todosMyticketsPost: $@\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 =  # Todos_mytickets_body | 

try: 
    # Get user tickets
    api_response = api_instance.todos_mytickets_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->todosMyticketsPost: %s\n" % e)

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

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

public class TodosApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        TodosApi apiInstance = new TodosApi();
        Todos_createevent_body body = ; // Todos_createevent_body | 
        try {
            Event result = apiInstance.todosCreateEventPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#todosCreateEventPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Todos_createevent_body *body = ; // 

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

// Create a new event
[apiInstance todosCreateEventPostWith:body
              completionHandler: ^(Event output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.TodosApi()
var body = ; // {{Todos_createevent_body}} 

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

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

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


            var apiInstance = new TodosApi();
            var body = new Todos_createevent_body(); // Todos_createevent_body | 

            try
            {
                // Create a new event
                Event result = apiInstance.todosCreateEventPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.todosCreateEventPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiTodosApi();
$body = ; // Todos_createevent_body | 

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

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


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

eval { 
    my $result = $api_instance->todosCreateEventPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TodosApi->todosCreateEventPost: $@\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.TodosApi()
body =  # Todos_createevent_body | 

try: 
    # Create a new event
    api_response = api_instance.todos_create_event_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->todosCreateEventPost: %s\n" % e)

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

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

public class TodosApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        TodosApi apiInstance = new TodosApi();
        Todos_createdevents_body body = ; // Todos_createdevents_body | 
        try {
            array[Event] result = apiInstance.todosCreatedEventsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#todosCreatedEventsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TodosApi;

public class TodosApiExample {

    public static void main(String[] args) {
        TodosApi apiInstance = new TodosApi();
        Todos_createdevents_body body = ; // Todos_createdevents_body | 
        try {
            array[Event] result = apiInstance.todosCreatedEventsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TodosApi#todosCreatedEventsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Todos_createdevents_body *body = ; // 

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

// Get created events for a user
[apiInstance todosCreatedEventsPostWith:body
              completionHandler: ^(array[Event] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.TodosApi()
var body = ; // {{Todos_createdevents_body}} 

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

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

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


            var apiInstance = new TodosApi();
            var body = new Todos_createdevents_body(); // Todos_createdevents_body | 

            try
            {
                // Get created events for a user
                array[Event] result = apiInstance.todosCreatedEventsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TodosApi.todosCreatedEventsPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiTodosApi();
$body = ; // Todos_createdevents_body | 

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

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


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

eval { 
    my $result = $api_instance->todosCreatedEventsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TodosApi->todosCreatedEventsPost: $@\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.TodosApi()
body =  # Todos_createdevents_body | 

try: 
    # Get created events for a user
    api_response = api_instance.todos_created_events_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TodosApi->todosCreatedEventsPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


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

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get information about the current user
[apiInstance userCurrentUserGetWithCompletionHandler: 
              ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


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

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

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


            var apiInstance = new UserApi();

            try
            {
                // Get information about the current user
                inline_response_200 result = apiInstance.userCurrentUserGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userCurrentUserGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

try: 
    # Get information about the current user
    api_response = api_instance.user_current_user_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userCurrentUserGet: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        User_login_body body = ; // User_login_body | 
        try {
            inline_response_200 result = apiInstance.userLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userLoginPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User_login_body *body = ; // 

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

// Verify user credentials and get a token
[apiInstance userLoginPostWith:body
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var body = ; // {{User_login_body}} 

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

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

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


            var apiInstance = new UserApi();
            var body = new User_login_body(); // User_login_body | 

            try
            {
                // Verify user credentials and get a token
                inline_response_200 result = apiInstance.userLoginPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userLoginPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User_login_body | 

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

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


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

eval { 
    my $result = $api_instance->userLoginPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userLoginPost: $@\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.UserApi()
body =  # User_login_body | 

try: 
    # Verify user credentials and get a token
    api_response = api_instance.user_login_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userLoginPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        User_newpassword_body body = ; // User_newpassword_body | 
        try {
            inline_response_201 result = apiInstance.userNewPasswordPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userNewPasswordPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User_newpassword_body *body = ; // 

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

// Set a new password for the user
[apiInstance userNewPasswordPostWith:body
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var body = ; // {{User_newpassword_body}} 

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

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

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


            var apiInstance = new UserApi();
            var body = new User_newpassword_body(); // User_newpassword_body | 

            try
            {
                // Set a new password for the user
                inline_response_201 result = apiInstance.userNewPasswordPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userNewPasswordPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User_newpassword_body | 

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

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


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

eval { 
    my $result = $api_instance->userNewPasswordPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userNewPasswordPost: $@\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.UserApi()
body =  # User_newpassword_body | 

try: 
    # Set a new password for the user
    api_response = api_instance.user_new_password_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userNewPasswordPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        User_resetpassword_body body = ; // User_resetpassword_body | 
        try {
            inline_response_201 result = apiInstance.userResetPasswordPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userResetPasswordPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User_resetpassword_body *body = ; // 

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

// Send a reset password email
[apiInstance userResetPasswordPostWith:body
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var body = ; // {{User_resetpassword_body}} 

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

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

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


            var apiInstance = new UserApi();
            var body = new User_resetpassword_body(); // User_resetpassword_body | 

            try
            {
                // Send a reset password email
                inline_response_201 result = apiInstance.userResetPasswordPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userResetPasswordPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User_resetpassword_body | 

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

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


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

eval { 
    my $result = $api_instance->userResetPasswordPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userResetPasswordPost: $@\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.UserApi()
body =  # User_resetpassword_body | 

try: 
    # Send a reset password email
    api_response = api_instance.user_reset_password_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userResetPasswordPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        User body = ; // User | 
        try {
            User result = apiInstance.userSignupPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userSignupPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User *body = ; // 

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

// Create a new user
[apiInstance userSignupPostWith:body
              completionHandler: ^(User output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var body = ; // {{User}} 

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

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

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


            var apiInstance = new UserApi();
            var body = new User(); // User | 

            try
            {
                // Create a new user
                User result = apiInstance.userSignupPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userSignupPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User | 

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

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


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

eval { 
    my $result = $api_instance->userSignupPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userSignupPost: $@\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.UserApi()
body =  # User | 

try: 
    # Create a new user
    api_response = api_instance.user_signup_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userSignupPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        User_validateemail_body body = ; // User_validateemail_body | 
        try {
            inline_response_201 result = apiInstance.userValidateEmailPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userValidateEmailPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
User_validateemail_body *body = ; // 

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

// Send email verification token
[apiInstance userValidateEmailPostWith:body
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var body = ; // {{User_validateemail_body}} 

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

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

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


            var apiInstance = new UserApi();
            var body = new User_validateemail_body(); // User_validateemail_body | 

            try
            {
                // Send email verification token
                inline_response_201 result = apiInstance.userValidateEmailPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userValidateEmailPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$body = ; // User_validateemail_body | 

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

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


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

eval { 
    my $result = $api_instance->userValidateEmailPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userValidateEmailPost: $@\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.UserApi()
body =  # User_validateemail_body | 

try: 
    # Send email verification token
    api_response = api_instance.user_validate_email_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userValidateEmailPost: %s\n" % e)

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

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        String id = id_example; // String | Verification token
        try {
            inline_response_201 result = apiInstance.userVerifyIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userVerifyIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String id = id_example; // String | Verification token
        try {
            inline_response_201 result = apiInstance.userVerifyIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userVerifyIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *id = id_example; // Verification token

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

// Verify user account with the provided token
[apiInstance userVerifyIdGetWith:id
              completionHandler: ^(inline_response_201 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EventTicketManagementApi = require('event__ticket_management_api');
var defaultClient = EventTicketManagementApi.ApiClient.instance;


var api = new EventTicketManagementApi.UserApi()
var id = id_example; // {{String}} Verification token

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

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

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


            var apiInstance = new UserApi();
            var id = id_example;  // String | Verification token

            try
            {
                // Verify user account with the provided token
                inline_response_201 result = apiInstance.userVerifyIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.userVerifyIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiUserApi();
$id = id_example; // String | Verification token

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

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


my $api_instance = WWW::SwaggerClient::UserApi->new();
my $id = id_example; # String | Verification token

eval { 
    my $result = $api_instance->userVerifyIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->userVerifyIdGet: $@\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.UserApi()
id = id_example # String | Verification token

try: 
    # Verify user account with the provided token
    api_response = api_instance.user_verify_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->userVerifyIdGet: %s\n" % e)