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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        SignUpCustomer signupPlanner = ; // SignUpCustomer | Sign up a Customer
        try {
            apiInstance.addCustomer(signupPlanner);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addCustomer");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        SignUpCustomer signupPlanner = ; // SignUpCustomer | Sign up a Customer
        try {
            apiInstance.addCustomer(signupPlanner);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addCustomer");
            e.printStackTrace();
        }
    }
}

SignUpCustomer *signupPlanner = ; // Sign up a Customer (optional)

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

// Adds a new user ( customer) to the system
[apiInstance addCustomerWith:signupPlanner
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'signupPlanner':  // {SignUpCustomer} Sign up a Customer
};

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

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

namespace Example
{
    public class addCustomerExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var signupPlanner = new SignUpCustomer(); // SignUpCustomer | Sign up a Customer (optional) 

            try
            {
                // Adds a new user ( customer) to the system
                apiInstance.addCustomer(signupPlanner);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.addCustomer: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$signupPlanner = ; // SignUpCustomer | Sign up a Customer

try {
    $api_instance->addCustomer($signupPlanner);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->addCustomer: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $signupPlanner = WWW::SwaggerClient::Object::SignUpCustomer->new(); # SignUpCustomer | Sign up a Customer

eval { 
    $api_instance->addCustomer(signupPlanner => $signupPlanner);
};
if ($@) {
    warn "Exception when calling AuthApi->addCustomer: $@\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.AuthApi()
signupPlanner =  # SignUpCustomer | Sign up a Customer (optional)

try: 
    # Adds a new user ( customer) to the system
    api_instance.add_customer(signupPlanner=signupPlanner)
except ApiException as e:
    print("Exception when calling AuthApi->addCustomer: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        SignUpMerchant signupMerchant = ; // SignUpMerchant | Sign up a Merchant
        try {
            apiInstance.addMerchant(signupMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addMerchant");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        SignUpMerchant signupMerchant = ; // SignUpMerchant | Sign up a Merchant
        try {
            apiInstance.addMerchant(signupMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addMerchant");
            e.printStackTrace();
        }
    }
}

SignUpMerchant *signupMerchant = ; // Sign up a Merchant (optional)

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

// Adds a new Service Provider/ Seller to the system
[apiInstance addMerchantWith:signupMerchant
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'signupMerchant':  // {SignUpMerchant} Sign up a Merchant
};

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

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

namespace Example
{
    public class addMerchantExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var signupMerchant = new SignUpMerchant(); // SignUpMerchant | Sign up a Merchant (optional) 

            try
            {
                // Adds a new Service Provider/ Seller to the system
                apiInstance.addMerchant(signupMerchant);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.addMerchant: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$signupMerchant = ; // SignUpMerchant | Sign up a Merchant

try {
    $api_instance->addMerchant($signupMerchant);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->addMerchant: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $signupMerchant = WWW::SwaggerClient::Object::SignUpMerchant->new(); # SignUpMerchant | Sign up a Merchant

eval { 
    $api_instance->addMerchant(signupMerchant => $signupMerchant);
};
if ($@) {
    warn "Exception when calling AuthApi->addMerchant: $@\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.AuthApi()
signupMerchant =  # SignUpMerchant | Sign up a Merchant (optional)

try: 
    # Adds a new Service Provider/ Seller to the system
    api_instance.add_merchant(signupMerchant=signupMerchant)
except ApiException as e:
    print("Exception when calling AuthApi->addMerchant: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        SignUpUser signupUser = ; // SignUpUser | Sign up a User
        try {
            apiInstance.addUser(signupUser);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addUser");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        SignUpUser signupUser = ; // SignUpUser | Sign up a User
        try {
            apiInstance.addUser(signupUser);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#addUser");
            e.printStackTrace();
        }
    }
}

SignUpUser *signupUser = ; // Sign up a User (optional)

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

// Adds a new user ( customer) to the system
[apiInstance addUserWith:signupUser
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'signupUser':  // {SignUpUser} Sign up a User
};

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

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

namespace Example
{
    public class addUserExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var signupUser = new SignUpUser(); // SignUpUser | Sign up a User (optional) 

            try
            {
                // Adds a new user ( customer) to the system
                apiInstance.addUser(signupUser);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.addUser: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$signupUser = ; // SignUpUser | Sign up a User

try {
    $api_instance->addUser($signupUser);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->addUser: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $signupUser = WWW::SwaggerClient::Object::SignUpUser->new(); # SignUpUser | Sign up a User

eval { 
    $api_instance->addUser(signupUser => $signupUser);
};
if ($@) {
    warn "Exception when calling AuthApi->addUser: $@\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.AuthApi()
signupUser =  # SignUpUser | Sign up a User (optional)

try: 
    # Adds a new user ( customer) to the system
    api_instance.add_user(signupUser=signupUser)
except ApiException as e:
    print("Exception when calling AuthApi->addUser: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        SignUpCustomer signupPlanner = ; // SignUpCustomer | Update Customer Profile
        try {
            apiInstance.editCustomerProfile(signupPlanner);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#editCustomerProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        SignUpCustomer signupPlanner = ; // SignUpCustomer | Update Customer Profile
        try {
            apiInstance.editCustomerProfile(signupPlanner);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#editCustomerProfile");
            e.printStackTrace();
        }
    }
}

SignUpCustomer *signupPlanner = ; // Update Customer Profile (optional)

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

// Edit/ Update Customer Profile
[apiInstance editCustomerProfileWith:signupPlanner
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'signupPlanner':  // {SignUpCustomer} Update Customer Profile
};

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

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

namespace Example
{
    public class editCustomerProfileExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var signupPlanner = new SignUpCustomer(); // SignUpCustomer | Update Customer Profile (optional) 

            try
            {
                // Edit/ Update Customer Profile
                apiInstance.editCustomerProfile(signupPlanner);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.editCustomerProfile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$signupPlanner = ; // SignUpCustomer | Update Customer Profile

try {
    $api_instance->editCustomerProfile($signupPlanner);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->editCustomerProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $signupPlanner = WWW::SwaggerClient::Object::SignUpCustomer->new(); # SignUpCustomer | Update Customer Profile

eval { 
    $api_instance->editCustomerProfile(signupPlanner => $signupPlanner);
};
if ($@) {
    warn "Exception when calling AuthApi->editCustomerProfile: $@\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.AuthApi()
signupPlanner =  # SignUpCustomer | Update Customer Profile (optional)

try: 
    # Edit/ Update Customer Profile
    api_instance.edit_customer_profile(signupPlanner=signupPlanner)
except ApiException as e:
    print("Exception when calling AuthApi->editCustomerProfile: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        SignUpMerchant signupMerchant = ; // SignUpMerchant | Update Merchant Profile
        try {
            apiInstance.editMerchntProfile(signupMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#editMerchntProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        SignUpMerchant signupMerchant = ; // SignUpMerchant | Update Merchant Profile
        try {
            apiInstance.editMerchntProfile(signupMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#editMerchntProfile");
            e.printStackTrace();
        }
    }
}

SignUpMerchant *signupMerchant = ; // Update Merchant Profile (optional)

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

// Edit/ update Merchant Profile
[apiInstance editMerchntProfileWith:signupMerchant
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'signupMerchant':  // {SignUpMerchant} Update Merchant Profile
};

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

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

namespace Example
{
    public class editMerchntProfileExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var signupMerchant = new SignUpMerchant(); // SignUpMerchant | Update Merchant Profile (optional) 

            try
            {
                // Edit/ update Merchant Profile
                apiInstance.editMerchntProfile(signupMerchant);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.editMerchntProfile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$signupMerchant = ; // SignUpMerchant | Update Merchant Profile

try {
    $api_instance->editMerchntProfile($signupMerchant);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->editMerchntProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $signupMerchant = WWW::SwaggerClient::Object::SignUpMerchant->new(); # SignUpMerchant | Update Merchant Profile

eval { 
    $api_instance->editMerchntProfile(signupMerchant => $signupMerchant);
};
if ($@) {
    warn "Exception when calling AuthApi->editMerchntProfile: $@\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.AuthApi()
signupMerchant =  # SignUpMerchant | Update Merchant Profile (optional)

try: 
    # Edit/ update Merchant Profile
    api_instance.edit_merchnt_profile(signupMerchant=signupMerchant)
except ApiException as e:
    print("Exception when calling AuthApi->editMerchntProfile: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        RemoveMerchant removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile
        try {
            apiInstance.removeMerchantProfile(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#removeMerchantProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        RemoveMerchant removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile
        try {
            apiInstance.removeMerchantProfile(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#removeMerchantProfile");
            e.printStackTrace();
        }
    }
}

RemoveMerchant *removeMerchant = ; // Deactivte Merchant Profile (optional)

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

// Deactivte Merchant Profile
[apiInstance removeMerchantProfileWith:removeMerchant
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'removeMerchant':  // {RemoveMerchant} Deactivte Merchant Profile
};

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

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

namespace Example
{
    public class removeMerchantProfileExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var removeMerchant = new RemoveMerchant(); // RemoveMerchant | Deactivte Merchant Profile (optional) 

            try
            {
                // Deactivte Merchant Profile
                apiInstance.removeMerchantProfile(removeMerchant);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.removeMerchantProfile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile

try {
    $api_instance->removeMerchantProfile($removeMerchant);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->removeMerchantProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $removeMerchant = WWW::SwaggerClient::Object::RemoveMerchant->new(); # RemoveMerchant | Deactivte Merchant Profile

eval { 
    $api_instance->removeMerchantProfile(removeMerchant => $removeMerchant);
};
if ($@) {
    warn "Exception when calling AuthApi->removeMerchantProfile: $@\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.AuthApi()
removeMerchant =  # RemoveMerchant | Deactivte Merchant Profile (optional)

try: 
    # Deactivte Merchant Profile
    api_instance.remove_merchant_profile(removeMerchant=removeMerchant)
except ApiException as e:
    print("Exception when calling AuthApi->removeMerchantProfile: %s\n" % e)

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

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        String userId = userId_example; // String | Id of the Signed User
        Integer email = 56; // Integer | email of he Signed User
        Integer userType = 56; // Integer | Type of the signed User
        try {
            array[signIn] result = apiInstance.signIn, signUp(userId, email, userType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#signIn, signUp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        String userId = userId_example; // String | Id of the Signed User
        Integer email = 56; // Integer | email of he Signed User
        Integer userType = 56; // Integer | Type of the signed User
        try {
            array[signIn] result = apiInstance.signIn, signUp(userId, email, userType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#signIn, signUp");
            e.printStackTrace();
        }
    }
}

String *userId = userId_example; // Id of the Signed User (optional)
Integer *email = 56; // email of he Signed User (optional)
Integer *userType = 56; // Type of the signed User (optional)

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

// Authentication hadeling, User data update and retrival
[apiInstance signIn, signUpWith:userId
    email:email
    userType:userType
              completionHandler: ^(array[signIn] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.AuthApi()

var opts = { 
  'userId': userId_example, // {String} Id of the Signed User
  'email': 56, // {Integer} email of he Signed User
  'userType': 56 // {Integer} Type of the signed User
};

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

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

namespace Example
{
    public class signIn, signUpExample
    {
        public void main()
        {
            
            var apiInstance = new AuthApi();
            var userId = userId_example;  // String | Id of the Signed User (optional) 
            var email = 56;  // Integer | email of he Signed User (optional) 
            var userType = 56;  // Integer | Type of the signed User (optional) 

            try
            {
                // Authentication hadeling, User data update and retrival
                array[signIn] result = apiInstance.signIn, signUp(userId, email, userType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.signIn, signUp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AuthApi();
$userId = userId_example; // String | Id of the Signed User
$email = 56; // Integer | email of he Signed User
$userType = 56; // Integer | Type of the signed User

try {
    $result = $api_instance->signIn, signUp($userId, $email, $userType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->signIn, signUp: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $userId = userId_example; # String | Id of the Signed User
my $email = 56; # Integer | email of he Signed User
my $userType = 56; # Integer | Type of the signed User

eval { 
    my $result = $api_instance->signIn, signUp(userId => $userId, email => $email, userType => $userType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->signIn, signUp: $@\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.AuthApi()
userId = userId_example # String | Id of the Signed User (optional)
email = 56 # Integer | email of he Signed User (optional)
userType = 56 # Integer | Type of the signed User (optional)

try: 
    # Authentication hadeling, User data update and retrival
    api_response = api_instance.sign_in,_sign_up(userId=userId, email=email, userType=userType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->signIn, signUp: %s\n" % e)

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

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

public class EventApiExample {

    public static void main(String[] args) {
        
        EventApi apiInstance = new EventApi();
        CreateEvent addNewEvent = ; // CreateEvent | Update Customer Profile
        try {
            apiInstance.addEvent(addNewEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#addEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventApi;

public class EventApiExample {

    public static void main(String[] args) {
        EventApi apiInstance = new EventApi();
        CreateEvent addNewEvent = ; // CreateEvent | Update Customer Profile
        try {
            apiInstance.addEvent(addNewEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#addEvent");
            e.printStackTrace();
        }
    }
}

CreateEvent *addNewEvent = ; // Update Customer Profile (optional)

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

// Create New Event under a selected Category
[apiInstance addEventWith:addNewEvent
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

var opts = { 
  'addNewEvent':  // {CreateEvent} Update Customer Profile
};

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

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

namespace Example
{
    public class addEventExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();
            var addNewEvent = new CreateEvent(); // CreateEvent | Update Customer Profile (optional) 

            try
            {
                // Create New Event under a selected Category
                apiInstance.addEvent(addNewEvent);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.addEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();
$addNewEvent = ; // CreateEvent | Update Customer Profile

try {
    $api_instance->addEvent($addNewEvent);
} catch (Exception $e) {
    echo 'Exception when calling EventApi->addEvent: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventApi->new();
my $addNewEvent = WWW::SwaggerClient::Object::CreateEvent->new(); # CreateEvent | Update Customer Profile

eval { 
    $api_instance->addEvent(addNewEvent => $addNewEvent);
};
if ($@) {
    warn "Exception when calling EventApi->addEvent: $@\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.EventApi()
addNewEvent =  # CreateEvent | Update Customer Profile (optional)

try: 
    # Create New Event under a selected Category
    api_instance.add_event(addNewEvent=addNewEvent)
except ApiException as e:
    print("Exception when calling EventApi->addEvent: %s\n" % e)

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

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

public class EventApiExample {

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

import io.swagger.client.api.EventApi;

public class EventApiExample {

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

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

// Get list of All published Events
[apiInstance getAllEventsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

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

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

namespace Example
{
    public class getAllEventsExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();

            try
            {
                // Get list of All published Events
                apiInstance.getAllEvents();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.getAllEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();

try {
    $api_instance->getAllEvents();
} catch (Exception $e) {
    echo 'Exception when calling EventApi->getAllEvents: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->getAllEvents();
};
if ($@) {
    warn "Exception when calling EventApi->getAllEvents: $@\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.EventApi()

try: 
    # Get list of All published Events
    api_instance.get_all_events()
except ApiException as e:
    print("Exception when calling EventApi->getAllEvents: %s\n" % e)

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

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

public class EventApiExample {

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

import io.swagger.client.api.EventApi;

public class EventApiExample {

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

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

// Get list of All published Events
[apiInstance getCustomerEventsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

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

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

namespace Example
{
    public class getCustomerEventsExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();

            try
            {
                // Get list of All published Events
                apiInstance.getCustomerEvents();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.getCustomerEvents: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();

try {
    $api_instance->getCustomerEvents();
} catch (Exception $e) {
    echo 'Exception when calling EventApi->getCustomerEvents: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->getCustomerEvents();
};
if ($@) {
    warn "Exception when calling EventApi->getCustomerEvents: $@\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.EventApi()

try: 
    # Get list of All published Events
    api_instance.get_customer_events()
except ApiException as e:
    print("Exception when calling EventApi->getCustomerEvents: %s\n" % e)

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

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

public class EventApiExample {

    public static void main(String[] args) {
        
        EventApi apiInstance = new EventApi();
        String event Id = event Id_example; // String | :id - Event Id
        try {
            apiInstance.getSingleEvent(event Id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#getSingleEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventApi;

public class EventApiExample {

    public static void main(String[] args) {
        EventApi apiInstance = new EventApi();
        String event Id = event Id_example; // String | :id - Event Id
        try {
            apiInstance.getSingleEvent(event Id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#getSingleEvent");
            e.printStackTrace();
        }
    }
}

String *event Id = event Id_example; // :id - Event Id (optional)

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

// Get details of an Event
[apiInstance getSingleEventWith:event Id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

var opts = { 
  'event Id': event Id_example // {String} :id - Event Id
};

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

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

namespace Example
{
    public class getSingleEventExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();
            var event Id = event Id_example;  // String | :id - Event Id (optional) 

            try
            {
                // Get details of an Event
                apiInstance.getSingleEvent(event Id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.getSingleEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();
$event Id = event Id_example; // String | :id - Event Id

try {
    $api_instance->getSingleEvent($event Id);
} catch (Exception $e) {
    echo 'Exception when calling EventApi->getSingleEvent: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventApi->new();
my $event Id = event Id_example; # String | :id - Event Id

eval { 
    $api_instance->getSingleEvent(event Id => $event Id);
};
if ($@) {
    warn "Exception when calling EventApi->getSingleEvent: $@\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.EventApi()
event Id = event Id_example # String | :id - Event Id (optional)

try: 
    # Get details of an Event
    api_instance.get_single_event(event Id=event Id)
except ApiException as e:
    print("Exception when calling EventApi->getSingleEvent: %s\n" % e)

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

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

public class EventApiExample {

    public static void main(String[] args) {
        
        EventApi apiInstance = new EventApi();
        PublishEvent publishEvent = ; // PublishEvent | Publish event state
        try {
            apiInstance.publishEvent(publishEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#publishEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventApi;

public class EventApiExample {

    public static void main(String[] args) {
        EventApi apiInstance = new EventApi();
        PublishEvent publishEvent = ; // PublishEvent | Publish event state
        try {
            apiInstance.publishEvent(publishEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#publishEvent");
            e.printStackTrace();
        }
    }
}

PublishEvent *publishEvent = ; // Publish event state (optional)

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

// Publish an event
[apiInstance publishEventWith:publishEvent
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

var opts = { 
  'publishEvent':  // {PublishEvent} Publish event state
};

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

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

namespace Example
{
    public class publishEventExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();
            var publishEvent = new PublishEvent(); // PublishEvent | Publish event state (optional) 

            try
            {
                // Publish an event
                apiInstance.publishEvent(publishEvent);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.publishEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();
$publishEvent = ; // PublishEvent | Publish event state

try {
    $api_instance->publishEvent($publishEvent);
} catch (Exception $e) {
    echo 'Exception when calling EventApi->publishEvent: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventApi->new();
my $publishEvent = WWW::SwaggerClient::Object::PublishEvent->new(); # PublishEvent | Publish event state

eval { 
    $api_instance->publishEvent(publishEvent => $publishEvent);
};
if ($@) {
    warn "Exception when calling EventApi->publishEvent: $@\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.EventApi()
publishEvent =  # PublishEvent | Publish event state (optional)

try: 
    # Publish an event
    api_instance.publish_event(publishEvent=publishEvent)
except ApiException as e:
    print("Exception when calling EventApi->publishEvent: %s\n" % e)

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

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

public class EventApiExample {

    public static void main(String[] args) {
        
        EventApi apiInstance = new EventApi();
        RemoveMerchant removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile
        try {
            apiInstance.removeEvent(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#removeEvent");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventApi;

public class EventApiExample {

    public static void main(String[] args) {
        EventApi apiInstance = new EventApi();
        RemoveMerchant removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile
        try {
            apiInstance.removeEvent(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#removeEvent");
            e.printStackTrace();
        }
    }
}

RemoveMerchant *removeMerchant = ; // Deactivte Merchant Profile (optional)

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

// Deactivte Merchant Profile
[apiInstance removeEventWith:removeMerchant
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

var opts = { 
  'removeMerchant':  // {RemoveMerchant} Deactivte Merchant Profile
};

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

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

namespace Example
{
    public class removeEventExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();
            var removeMerchant = new RemoveMerchant(); // RemoveMerchant | Deactivte Merchant Profile (optional) 

            try
            {
                // Deactivte Merchant Profile
                apiInstance.removeEvent(removeMerchant);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.removeEvent: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();
$removeMerchant = ; // RemoveMerchant | Deactivte Merchant Profile

try {
    $api_instance->removeEvent($removeMerchant);
} catch (Exception $e) {
    echo 'Exception when calling EventApi->removeEvent: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventApi->new();
my $removeMerchant = WWW::SwaggerClient::Object::RemoveMerchant->new(); # RemoveMerchant | Deactivte Merchant Profile

eval { 
    $api_instance->removeEvent(removeMerchant => $removeMerchant);
};
if ($@) {
    warn "Exception when calling EventApi->removeEvent: $@\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.EventApi()
removeMerchant =  # RemoveMerchant | Deactivte Merchant Profile (optional)

try: 
    # Deactivte Merchant Profile
    api_instance.remove_event(removeMerchant=removeMerchant)
except ApiException as e:
    print("Exception when calling EventApi->removeEvent: %s\n" % e)

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

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

public class EventApiExample {

    public static void main(String[] args) {
        
        EventApi apiInstance = new EventApi();
        RemoveEvent updateEvent = ; // RemoveEvent | Update Event details
        try {
            apiInstance.updateEventDetails(updateEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#updateEventDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EventApi;

public class EventApiExample {

    public static void main(String[] args) {
        EventApi apiInstance = new EventApi();
        RemoveEvent updateEvent = ; // RemoveEvent | Update Event details
        try {
            apiInstance.updateEventDetails(updateEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventApi#updateEventDetails");
            e.printStackTrace();
        }
    }
}

RemoveEvent *updateEvent = ; // Update Event details (optional)

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

// Edit/ update Event details
[apiInstance updateEventDetailsWith:updateEvent
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.EventApi()

var opts = { 
  'updateEvent':  // {RemoveEvent} Update Event details
};

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

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

namespace Example
{
    public class updateEventDetailsExample
    {
        public void main()
        {
            
            var apiInstance = new EventApi();
            var updateEvent = new RemoveEvent(); // RemoveEvent | Update Event details (optional) 

            try
            {
                // Edit/ update Event details
                apiInstance.updateEventDetails(updateEvent);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EventApi.updateEventDetails: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\EventApi();
$updateEvent = ; // RemoveEvent | Update Event details

try {
    $api_instance->updateEventDetails($updateEvent);
} catch (Exception $e) {
    echo 'Exception when calling EventApi->updateEventDetails: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::EventApi->new();
my $updateEvent = WWW::SwaggerClient::Object::RemoveEvent->new(); # RemoveEvent | Update Event details

eval { 
    $api_instance->updateEventDetails(updateEvent => $updateEvent);
};
if ($@) {
    warn "Exception when calling EventApi->updateEventDetails: $@\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.EventApi()
updateEvent =  # RemoveEvent | Update Event details (optional)

try: 
    # Edit/ update Event details
    api_instance.update_event_details(updateEvent=updateEvent)
except ApiException as e:
    print("Exception when calling EventApi->updateEventDetails: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        
        ServiceApi apiInstance = new ServiceApi();
        CreateService createService = ; // CreateService | Update Event details
        try {
            apiInstance.createService(createService);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#createService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        CreateService createService = ; // CreateService | Update Event details
        try {
            apiInstance.createService(createService);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#createService");
            e.printStackTrace();
        }
    }
}

CreateService *createService = ; // Update Event details (optional)

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

// Add new Service
[apiInstance createServiceWith:createService
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

var opts = { 
  'createService':  // {CreateService} Update Event details
};

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

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

namespace Example
{
    public class createServiceExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();
            var createService = new CreateService(); // CreateService | Update Event details (optional) 

            try
            {
                // Add new Service
                apiInstance.createService(createService);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.createService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();
$createService = ; // CreateService | Update Event details

try {
    $api_instance->createService($createService);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->createService: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $createService = WWW::SwaggerClient::Object::CreateService->new(); # CreateService | Update Event details

eval { 
    $api_instance->createService(createService => $createService);
};
if ($@) {
    warn "Exception when calling ServiceApi->createService: $@\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.ServiceApi()
createService =  # CreateService | Update Event details (optional)

try: 
    # Add new Service
    api_instance.create_service(createService=createService)
except ApiException as e:
    print("Exception when calling ServiceApi->createService: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        
        ServiceApi apiInstance = new ServiceApi();
        CreateService updateService = ; // CreateService | Update Event details
        try {
            apiInstance.editService(updateService);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#editService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        CreateService updateService = ; // CreateService | Update Event details
        try {
            apiInstance.editService(updateService);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#editService");
            e.printStackTrace();
        }
    }
}

CreateService *updateService = ; // Update Event details (optional)

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

// Edit/ update Service details
[apiInstance editServiceWith:updateService
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

var opts = { 
  'updateService':  // {CreateService} Update Event details
};

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

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

namespace Example
{
    public class editServiceExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();
            var updateService = new CreateService(); // CreateService | Update Event details (optional) 

            try
            {
                // Edit/ update Service details
                apiInstance.editService(updateService);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.editService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();
$updateService = ; // CreateService | Update Event details

try {
    $api_instance->editService($updateService);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->editService: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $updateService = WWW::SwaggerClient::Object::CreateService->new(); # CreateService | Update Event details

eval { 
    $api_instance->editService(updateService => $updateService);
};
if ($@) {
    warn "Exception when calling ServiceApi->editService: $@\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.ServiceApi()
updateService =  # CreateService | Update Event details (optional)

try: 
    # Edit/ update Service details
    api_instance.edit_service(updateService=updateService)
except ApiException as e:
    print("Exception when calling ServiceApi->editService: %s\n" % e)

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

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

public class ServiceApiExample {

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

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

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

// Get list of All Services
[apiInstance getAllServicesWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

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

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

namespace Example
{
    public class getAllServicesExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();

            try
            {
                // Get list of All Services
                apiInstance.getAllServices();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.getAllServices: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();

try {
    $api_instance->getAllServices();
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->getAllServices: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->getAllServices();
};
if ($@) {
    warn "Exception when calling ServiceApi->getAllServices: $@\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.ServiceApi()

try: 
    # Get list of All Services
    api_instance.get_all_services()
except ApiException as e:
    print("Exception when calling ServiceApi->getAllServices: %s\n" % e)

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

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

public class ServiceApiExample {

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

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

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

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

// Get list of All published Events
[apiInstance getServiceProviderSericesWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

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

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

namespace Example
{
    public class getServiceProviderSericesExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();

            try
            {
                // Get list of All published Events
                apiInstance.getServiceProviderSerices();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.getServiceProviderSerices: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();

try {
    $api_instance->getServiceProviderSerices();
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->getServiceProviderSerices: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->getServiceProviderSerices();
};
if ($@) {
    warn "Exception when calling ServiceApi->getServiceProviderSerices: $@\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.ServiceApi()

try: 
    # Get list of All published Events
    api_instance.get_service_provider_serices()
except ApiException as e:
    print("Exception when calling ServiceApi->getServiceProviderSerices: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        
        ServiceApi apiInstance = new ServiceApi();
        String service Id = service Id_example; // String | :id - Service Id
        try {
            apiInstance.getSingleService(service Id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getSingleService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String service Id = service Id_example; // String | :id - Service Id
        try {
            apiInstance.getSingleService(service Id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getSingleService");
            e.printStackTrace();
        }
    }
}

String *service Id = service Id_example; // :id - Service Id (optional)

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

// Get details of a Service
[apiInstance getSingleServiceWith:service Id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

var opts = { 
  'service Id': service Id_example // {String} :id - Service Id
};

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

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

namespace Example
{
    public class getSingleServiceExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();
            var service Id = service Id_example;  // String | :id - Service Id (optional) 

            try
            {
                // Get details of a Service
                apiInstance.getSingleService(service Id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.getSingleService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();
$service Id = service Id_example; // String | :id - Service Id

try {
    $api_instance->getSingleService($service Id);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->getSingleService: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $service Id = service Id_example; # String | :id - Service Id

eval { 
    $api_instance->getSingleService(service Id => $service Id);
};
if ($@) {
    warn "Exception when calling ServiceApi->getSingleService: $@\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.ServiceApi()
service Id = service Id_example # String | :id - Service Id (optional)

try: 
    # Get details of a Service
    api_instance.get_single_service(service Id=service Id)
except ApiException as e:
    print("Exception when calling ServiceApi->getSingleService: %s\n" % e)

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

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

public class ServiceApiExample {

    public static void main(String[] args) {
        
        ServiceApi apiInstance = new ServiceApi();
        RemoveService removeMerchant = ; // RemoveService | Remove a Service
        try {
            apiInstance.removeService(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#removeService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServiceApi;

public class ServiceApiExample {

    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        RemoveService removeMerchant = ; // RemoveService | Remove a Service
        try {
            apiInstance.removeService(removeMerchant);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#removeService");
            e.printStackTrace();
        }
    }
}

RemoveService *removeMerchant = ; // Remove a Service (optional)

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

// Remove a Service
[apiInstance removeServiceWith:removeMerchant
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EvenzaApiDocumentation = require('evenza___api_documentation');

var api = new EvenzaApiDocumentation.ServiceApi()

var opts = { 
  'removeMerchant':  // {RemoveService} Remove a Service
};

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

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

namespace Example
{
    public class removeServiceExample
    {
        public void main()
        {
            
            var apiInstance = new ServiceApi();
            var removeMerchant = new RemoveService(); // RemoveService | Remove a Service (optional) 

            try
            {
                // Remove a Service
                apiInstance.removeService(removeMerchant);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServiceApi.removeService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\ServiceApi();
$removeMerchant = ; // RemoveService | Remove a Service

try {
    $api_instance->removeService($removeMerchant);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->removeService: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::ServiceApi->new();
my $removeMerchant = WWW::SwaggerClient::Object::RemoveService->new(); # RemoveService | Remove a Service

eval { 
    $api_instance->removeService(removeMerchant => $removeMerchant);
};
if ($@) {
    warn "Exception when calling ServiceApi->removeService: $@\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.ServiceApi()
removeMerchant =  # RemoveService | Remove a Service (optional)

try: 
    # Remove a Service
    api_instance.remove_service(removeMerchant=removeMerchant)
except ApiException as e:
    print("Exception when calling ServiceApi->removeService: %s\n" % e)