TIXNGO REST API

Default

organizerAccessValidationOptions

CORS support

Enable CORS by returning correct headers


/organizer/access/validation

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/access/validation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerAccessValidationOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccessValidationOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerAccessValidationOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerAccessValidationOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccessValidationOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerAccessValidationOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccessValidationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerAccessValidationOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccessValidationOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerAccessValidationOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccessValidationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_access_validation_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccessValidationOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerAccessValidationPost

Validate the qrcode passed in parameter according to the chosen mode


/organizer/access/validation

Usage and SDK Samples

curl -X POST\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/access/validation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccessValidationRequest organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest | 
        
        try {
            OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccessValidationPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccessValidationRequest organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest | 
        
        try {
            OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccessValidationPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
OrganizerAccessValidationRequest *organizerAccessValidationRequest = ; //  (optional)

[apiInstance organizerAccessValidationPostWith:organizerAccessValidationRequest
              completionHandler: ^(OrganizerAccessValidationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var opts = {
  'organizerAccessValidationRequest':  // {OrganizerAccessValidationRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerAccessValidationPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccessValidationPostExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerAccessValidationRequest = new OrganizerAccessValidationRequest(); // OrganizerAccessValidationRequest |  (optional) 

            try {
                OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccessValidationPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest | 

try {
    $result = $api_instance->organizerAccessValidationPost($organizerAccessValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccessValidationPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $organizerAccessValidationRequest = WWW::OPenAPIClient::Object::OrganizerAccessValidationRequest->new(); # OrganizerAccessValidationRequest | 

eval { 
    my $result = $api_instance->organizerAccessValidationPost(organizerAccessValidationRequest => $organizerAccessValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccessValidationPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerAccessValidationRequest =  # OrganizerAccessValidationRequest |  (optional)

try: 
    api_response = api_instance.organizer_access_validation_post(organizerAccessValidationRequest=organizerAccessValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccessValidationPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest

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

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

Scopes

Parameters

Body parameters
Name Description
organizerAccessValidationRequest

Responses


organizerAccountDelete

Delete the given operator account


/organizer/account

Usage and SDK Samples

curl -X DELETE\
-H "x-api-key: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/account?email="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String email = email_example; // String | 
        
        try {
            apiInstance.organizerAccountDelete(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String email = email_example; // String | 
        
        try {
            apiInstance.organizerAccountDelete(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *email = email_example; //  (default to null)

[apiInstance organizerAccountDeleteWith:email
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var email = email_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerAccountDelete(email, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccountDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var email = email_example;  // String |  (default to null)

            try {
                apiInstance.organizerAccountDelete(email);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$email = email_example; // String | 

try {
    $api_instance->organizerAccountDelete($email);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccountDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $email = email_example; # String | 

eval { 
    $api_instance->organizerAccountDelete(email => $email);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
email = email_example # String |  (default to null)

try: 
    api_instance.organizer_account_delete(email)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let email = email_example; // String

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

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

Scopes

Parameters

Query parameters
Name Description
email*
String
Required

Responses


organizerAccountOptions

CORS support

Enable CORS by returning correct headers


/organizer/account

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/account"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerAccountOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerAccountOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerAccountOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccountOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerAccountOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerAccountOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccountOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerAccountOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_account_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerAccountPost

Request a new operator account with given role


/organizer/account

Usage and SDK Samples

curl -X POST\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/account"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccountRequest organizerAccountRequest = ; // OrganizerAccountRequest | 
        
        try {
            OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccountRequest organizerAccountRequest = ; // OrganizerAccountRequest | 
        
        try {
            OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
OrganizerAccountRequest *organizerAccountRequest = ; //  (optional)

[apiInstance organizerAccountPostWith:organizerAccountRequest
              completionHandler: ^(OrganizerAccount output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var opts = {
  'organizerAccountRequest':  // {OrganizerAccountRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerAccountPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccountPostExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerAccountRequest = new OrganizerAccountRequest(); // OrganizerAccountRequest |  (optional) 

            try {
                OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$organizerAccountRequest = ; // OrganizerAccountRequest | 

try {
    $result = $api_instance->organizerAccountPost($organizerAccountRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccountPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $organizerAccountRequest = WWW::OPenAPIClient::Object::OrganizerAccountRequest->new(); # OrganizerAccountRequest | 

eval { 
    my $result = $api_instance->organizerAccountPost(organizerAccountRequest => $organizerAccountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerAccountRequest =  # OrganizerAccountRequest |  (optional)

try: 
    api_response = api_instance.organizer_account_post(organizerAccountRequest=organizerAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerAccountRequest = ; // OrganizerAccountRequest

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

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

Scopes

Parameters

Body parameters
Name Description
organizerAccountRequest

Responses


organizerAccountsGet

Retrieve the requester accounts as list


/organizer/accounts

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/accounts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerAccountsGetWithCompletionHandler: 
              ^(array[OrganizerAccount] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerAccountsGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccountsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->organizerAccountsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccountsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    my $result = $api_instance->organizerAccountsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_response = api_instance.organizer_accounts_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerAccountsOptions

CORS support

Enable CORS by returning correct headers


/organizer/accounts

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/accounts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerAccountsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerAccountsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerAccountsOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerAccountsOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerAccountsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerAccountsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerAccountsOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerAccountsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_accounts_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerActivationGet

[OPERATOR] Ask the backend to check for organizer activation status.


/organizer/activation

Usage and SDK Samples

curl -X GET\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/activation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerActivationResponse result = apiInstance.organizerActivationGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerActivationGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerActivationResponse result = apiInstance.organizerActivationGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerActivationGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerActivationGetWithCompletionHandler: 
              ^(OrganizerActivationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerActivationGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerActivationGetExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerActivationResponse result = apiInstance.organizerActivationGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerActivationGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->organizerActivationGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerActivationGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    my $result = $api_instance->organizerActivationGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerActivationGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_response = api_instance.organizer_activation_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerActivationGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerActivationOptions

CORS support

Enable CORS by returning correct headers


/organizer/activation

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/activation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerActivationOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerActivationOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerActivationOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerActivationOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerActivationOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerActivationOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerActivationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerActivationOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerActivationOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerActivationOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerActivationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_activation_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerActivationOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerApikeyDelete

[OPERATOR] Delete/Revoke the apikey for the current organizer.


/organizer/apikey

Usage and SDK Samples

curl -X DELETE\
-H "Authorization: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/apikey"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApikeyDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApikeyDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerApikeyDeleteWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApikeyDelete(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApikeyDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                apiInstance.organizerApikeyDelete();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApikeyDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerApikeyDelete();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApikeyDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerApikeyDelete();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApikeyDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_instance.organizer_apikey_delete()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApikeyDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerApikeyGet

[OPERATOR] Get the apikey for the current organizer. If the key does not exist, this method implicitly creates one.


/organizer/apikey

Usage and SDK Samples

curl -X GET\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/apikey"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerApikeyGetWithCompletionHandler: 
              ^(OrganizerApikeyResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerApikeyGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApikeyGetExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApikeyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->organizerApikeyGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApikeyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    my $result = $api_instance->organizerApikeyGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApikeyGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_response = api_instance.organizer_apikey_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApikeyGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerApikeyOptions

CORS support

Enable CORS by returning correct headers


/organizer/apikey

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/apikey"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApikeyOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerApikeyOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApikeyOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApikeyOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerApikeyOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApikeyOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerApikeyOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApikeyOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerApikeyOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApikeyOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_apikey_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApikeyOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerApplicationFeaturesAppIdGet

Get the list of all the organizer's application features, for all applications


/organizer/application-features/{appId}

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-features/{appId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        
        try {
            array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        
        try {
            array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *appId = appId_example; // the app id related to the feature (default to null)

[apiInstance organizerApplicationFeaturesAppIdGetWith:appId
              completionHandler: ^(array[OrganizerApplicationFeature] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var appId = appId_example; // {String} the app id related to the feature

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerApplicationFeaturesAppIdGet(appId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationFeaturesAppIdGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var appId = appId_example;  // String | the app id related to the feature (default to null)

            try {
                array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$appId = appId_example; // String | the app id related to the feature

try {
    $result = $api_instance->organizerApplicationFeaturesAppIdGet($appId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationFeaturesAppIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $appId = appId_example; # String | the app id related to the feature

eval { 
    my $result = $api_instance->organizerApplicationFeaturesAppIdGet(appId => $appId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationFeaturesAppIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appId = appId_example # String | the app id related to the feature (default to null)

try: 
    api_response = api_instance.organizer_application_features_app_id_get(appId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationFeaturesAppIdGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let appId = appId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
appId*
String
the app id related to the feature
Required

Responses


organizerApplicationFeaturesAppIdOptions

CORS support

Enable CORS by returning correct headers


/organizer/application-features/{appId}

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/application-features/{appId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApplicationFeaturesAppIdOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerApplicationFeaturesAppIdOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApplicationFeaturesAppIdOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationFeaturesAppIdOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerApplicationFeaturesAppIdOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerApplicationFeaturesAppIdOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationFeaturesAppIdOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerApplicationFeaturesAppIdOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationFeaturesAppIdOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_application_features_app_id_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationFeaturesAppIdOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerApplicationFeaturesAppIdPatch

Get the list of all the organizer's application features, for all applications


/organizer/application-features/{appId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/application-features/{appId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        array[OrganizerApplicationFeature] organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 
        
        try {
            apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        array[OrganizerApplicationFeature] organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 
        
        try {
            apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *appId = appId_example; // the app id related to the feature (default to null)
array[OrganizerApplicationFeature] *organizerApplicationFeature = ; //  (optional)

[apiInstance organizerApplicationFeaturesAppIdPatchWith:appId
    organizerApplicationFeature:organizerApplicationFeature
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var appId = appId_example; // {String} the app id related to the feature
var opts = {
  'organizerApplicationFeature':  // {array[OrganizerApplicationFeature]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApplicationFeaturesAppIdPatch(appId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationFeaturesAppIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var appId = appId_example;  // String | the app id related to the feature (default to null)
            var organizerApplicationFeature = new array[OrganizerApplicationFeature](); // array[OrganizerApplicationFeature] |  (optional) 

            try {
                apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$appId = appId_example; // String | the app id related to the feature
$organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 

try {
    $api_instance->organizerApplicationFeaturesAppIdPatch($appId, $organizerApplicationFeature);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $appId = appId_example; # String | the app id related to the feature
my $organizerApplicationFeature = [WWW::OPenAPIClient::Object::array[OrganizerApplicationFeature]->new()]; # array[OrganizerApplicationFeature] | 

eval { 
    $api_instance->organizerApplicationFeaturesAppIdPatch(appId => $appId, organizerApplicationFeature => $organizerApplicationFeature);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appId = appId_example # String | the app id related to the feature (default to null)
organizerApplicationFeature =  # array[OrganizerApplicationFeature] |  (optional)

try: 
    api_instance.organizer_application_features_app_id_patch(appId, organizerApplicationFeature=organizerApplicationFeature)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let appId = appId_example; // String
    let organizerApplicationFeature = ; // array[OrganizerApplicationFeature]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
appId*
String
the app id related to the feature
Required
Body parameters
Name Description
organizerApplicationFeature

Responses


organizerApplicationSettingsGet

Get the spectator application settings for the applications (mobileAppId)


/organizer/application-settings

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-settings?mobileAppId=&key=&offset=&limit="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        
        try {
            ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        
        try {
            ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *offset = offset_example; //  (default to null)
String *limit = limit_example; //  (default to null)
String *mobileAppId = mobileAppId_example; //  (optional) (default to null)
String *key = key_example; //  (optional) (default to null)

[apiInstance organizerApplicationSettingsGetWith:offset
    limit:limit
    mobileAppId:mobileAppId
    key:key
              completionHandler: ^(ApplicationSettings output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var offset = offset_example; // {String} 
var limit = limit_example; // {String} 
var opts = {
  'mobileAppId': mobileAppId_example, // {String} 
  'key': key_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerApplicationSettingsGet(offset, limit, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationSettingsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = offset_example;  // String |  (default to null)
            var limit = limit_example;  // String |  (default to null)
            var mobileAppId = mobileAppId_example;  // String |  (optional)  (default to null)
            var key = key_example;  // String |  (optional)  (default to null)

            try {
                ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = offset_example; // String | 
$limit = limit_example; // String | 
$mobileAppId = mobileAppId_example; // String | 
$key = key_example; // String | 

try {
    $result = $api_instance->organizerApplicationSettingsGet($offset, $limit, $mobileAppId, $key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $offset = offset_example; # String | 
my $limit = limit_example; # String | 
my $mobileAppId = mobileAppId_example; # String | 
my $key = key_example; # String | 

eval { 
    my $result = $api_instance->organizerApplicationSettingsGet(offset => $offset, limit => $limit, mobileAppId => $mobileAppId, key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
offset = offset_example # String |  (default to null)
limit = limit_example # String |  (default to null)
mobileAppId = mobileAppId_example # String |  (optional) (default to null)
key = key_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_application_settings_get(offset, limit, mobileAppId=mobileAppId, key=key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let offset = offset_example; // String
    let limit = limit_example; // String
    let mobileAppId = mobileAppId_example; // String
    let key = key_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerApplicationSettingsGet(offset, limit, mobileAppId, key, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
mobileAppId
String
key
String
offset*
String
Required
limit*
String
Required

Responses


organizerApplicationSettingsMobileAppIdSupportedLanguagesGet

Get a list of supported languages for the given mobileAppId


/organizer/application-settings/{mobile-app-id}/supported-languages

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-settings/{mobile-app-id}/supported-languages"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        
        try {
            array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        
        try {
            array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; //  (default to null)

[apiInstance organizerApplicationSettingsMobileAppIdSupportedLanguagesGetWith:mobileAppId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationSettingsMobileAppIdSupportedLanguagesGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)

            try {
                array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mobileAppId = mobileAppId_example; // String | 

try {
    $result = $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet($mobileAppId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $mobileAppId = mobileAppId_example; # String | 

eval { 
    my $result = $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId => $mobileAppId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
mobileAppId = mobileAppId_example # String |  (default to null)

try: 
    api_response = api_instance.organizer_application_settings_mobile_app_id_supported_languages_get(mobileAppId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
mobile-app-id*
String
Required

Responses


organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions

CORS support

Enable CORS by returning correct headers


/organizer/application-settings/{mobile-app-id}/supported-languages

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/application-settings/{mobile-app-id}/supported-languages"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerApplicationSettingsMobileAppIdSupportedLanguagesOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationSettingsMobileAppIdSupportedLanguagesOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_application_settings_mobile_app_id_supported_languages_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerApplicationSettingsOptions

CORS support

Enable CORS by returning correct headers


/organizer/application-settings

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/application-settings"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApplicationSettingsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerApplicationSettingsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApplicationSettingsOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerApplicationSettingsOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerApplicationSettingsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerApplicationSettingsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_application_settings_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerCommunicationsGet

Get the communication logs for the caller (organizer)


/organizer/communications

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/communications?limit=&offset=&email=&phoneNumber=&type=&status=&from=&to="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String email = email_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        
        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String email = email_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        
        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; //  (default to null)
String *offset = offset_example; //  (default to null)
String *email = email_example; //  (optional) (default to null)
String *phoneNumber = phoneNumber_example; //  (optional) (default to null)
String *type = type_example; //  (optional) (default to null)
String *status = status_example; //  (optional) (default to null)
String *from = from_example; //  (optional) (default to null)
String *to = to_example; //  (optional) (default to null)

[apiInstance organizerCommunicationsGetWith:limit
    offset:offset
    email:email
    phoneNumber:phoneNumber
    type:type
    status:status
    from:from
    to:to
              completionHandler: ^(OrganizerCommunicationLogsSearchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var limit = limit_example; // {String} 
var offset = offset_example; // {String} 
var opts = {
  'email': email_example, // {String} 
  'phoneNumber': phoneNumber_example, // {String} 
  'type': type_example, // {String} 
  'status': status_example, // {String} 
  'from': from_example, // {String} 
  'to': to_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerCommunicationsGet(limit, offset, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerCommunicationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String |  (default to null)
            var offset = offset_example;  // String |  (default to null)
            var email = email_example;  // String |  (optional)  (default to null)
            var phoneNumber = phoneNumber_example;  // String |  (optional)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)
            var status = status_example;  // String |  (optional)  (default to null)
            var from = from_example;  // String |  (optional)  (default to null)
            var to = to_example;  // String |  (optional)  (default to null)

            try {
                OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerCommunicationsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | 
$offset = offset_example; // String | 
$email = email_example; // String | 
$phoneNumber = phoneNumber_example; // String | 
$type = type_example; // String | 
$status = status_example; // String | 
$from = from_example; // String | 
$to = to_example; // String | 

try {
    $result = $api_instance->organizerCommunicationsGet($limit, $offset, $email, $phoneNumber, $type, $status, $from, $to);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerCommunicationsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | 
my $offset = offset_example; # String | 
my $email = email_example; # String | 
my $phoneNumber = phoneNumber_example; # String | 
my $type = type_example; # String | 
my $status = status_example; # String | 
my $from = from_example; # String | 
my $to = to_example; # String | 

eval { 
    my $result = $api_instance->organizerCommunicationsGet(limit => $limit, offset => $offset, email => $email, phoneNumber => $phoneNumber, type => $type, status => $status, from => $from, to => $to);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerCommunicationsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String |  (default to null)
offset = offset_example # String |  (default to null)
email = email_example # String |  (optional) (default to null)
phoneNumber = phoneNumber_example # String |  (optional) (default to null)
type = type_example # String |  (optional) (default to null)
status = status_example # String |  (optional) (default to null)
from = from_example # String |  (optional) (default to null)
to = to_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_communications_get(limit, offset, email=email, phoneNumber=phoneNumber, type=type, status=status, from=from, to=to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerCommunicationsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let email = email_example; // String
    let phoneNumber = phoneNumber_example; // String
    let type = type_example; // String
    let status = status_example; // String
    let from = from_example; // String
    let to = to_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
limit*
String
Required
offset*
String
Required
email
String
phoneNumber
String
type
String
status
String
from
String
to
String

Responses


organizerCommunicationsOptions

CORS support

Enable CORS by returning correct headers


/organizer/communications

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/communications"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerCommunicationsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerCommunicationsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerCommunicationsOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerCommunicationsOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerCommunicationsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerCommunicationsOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerCommunicationsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerCommunicationsOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerCommunicationsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerCommunicationsOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_communications_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerCommunicationsOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerConfigGet

[PUBLIC] Get the initial configuration necessary for an operator to begin the authentication process


/organizer/config

Usage and SDK Samples

curl -X GET\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/config"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerConfig result = apiInstance.organizerConfigGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

[apiInstance organizerConfigGetWithCompletionHandler: 
              ^(OrganizerConfig output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerConfigGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerConfigGetExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerConfig result = apiInstance.organizerConfigGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerConfigGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->organizerConfigGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerConfigGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    my $result = $api_instance->organizerConfigGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerConfigGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_response = api_instance.organizer_config_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerConfigGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerConfigOptions

CORS support

Enable CORS by returning correct headers


/organizer/config

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/config"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerConfigOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerConfigOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerConfigOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerConfigOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerConfigOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerConfigOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerConfigOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerConfigOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerConfigOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerConfigOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_config_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerConfigOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsAllGet

Get the list of events of the caller (organizer) without paging


/organizer/events/all

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/all"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerEventsAllGetWithCompletionHandler: 
              ^(array[OrganizerAllEventsResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsAllGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsAllGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsAllGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->organizerEventsAllGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsAllGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    my $result = $api_instance->organizerEventsAllGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsAllGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    api_response = api_instance.organizer_events_all_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsAllGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerEventsAllOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/all

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/all"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsAllOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsAllOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsAllOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsAllOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsAllOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsAllOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsAllOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsAllOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsAllOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsAllOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_all_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsAllOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdActivationIdOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}/{activationId}

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/{activationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdActivationIdOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdActivationIdOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdActivationIdOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdActivationIdOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsEventIdActivationIdOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdActivationIdOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsEventIdActivationIdOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdActivationIdOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsEventIdActivationIdOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdActivationIdOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_event_id_activation_id_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdActivationIdOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdActivationIdPatch

Update the activation information of a sub group of tickets sharing the same eventId and activationId. This path ensure that the tickets keep coherent data between them


/organizer/events/{eventId}/{activationId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/{activationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String activationId = activationId_example; // String | 
        String eventId = eventId_example; // String | 
        OrganizerTicketActivationPatch organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 
        
        try {
            apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String activationId = activationId_example; // String | 
        String eventId = eventId_example; // String | 
        OrganizerTicketActivationPatch organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 
        
        try {
            apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *activationId = activationId_example; //  (default to null)
String *eventId = eventId_example; //  (default to null)
OrganizerTicketActivationPatch *organizerTicketActivationPatch = ; // 

[apiInstance organizerEventsEventIdActivationIdPatchWith:activationId
    eventId:eventId
    organizerTicketActivationPatch:organizerTicketActivationPatch
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var activationId = activationId_example; // {String} 
var eventId = eventId_example; // {String} 
var organizerTicketActivationPatch = ; // {OrganizerTicketActivationPatch} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdActivationIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var activationId = activationId_example;  // String |  (default to null)
            var eventId = eventId_example;  // String |  (default to null)
            var organizerTicketActivationPatch = new OrganizerTicketActivationPatch(); // OrganizerTicketActivationPatch | 

            try {
                apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdActivationIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$activationId = activationId_example; // String | 
$eventId = eventId_example; // String | 
$organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 

try {
    $api_instance->organizerEventsEventIdActivationIdPatch($activationId, $eventId, $organizerTicketActivationPatch);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $activationId = activationId_example; # String | 
my $eventId = eventId_example; # String | 
my $organizerTicketActivationPatch = WWW::OPenAPIClient::Object::OrganizerTicketActivationPatch->new(); # OrganizerTicketActivationPatch | 

eval { 
    $api_instance->organizerEventsEventIdActivationIdPatch(activationId => $activationId, eventId => $eventId, organizerTicketActivationPatch => $organizerTicketActivationPatch);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
activationId = activationId_example # String |  (default to null)
eventId = eventId_example # String |  (default to null)
organizerTicketActivationPatch =  # OrganizerTicketActivationPatch | 

try: 
    api_instance.organizer_events_event_id_activation_id_patch(activationId, eventId, organizerTicketActivationPatch)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let activationId = activationId_example; // String
    let eventId = eventId_example; // String
    let organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
activationId*
String
Required
eventId*
String
Required
Body parameters
Name Description
organizerTicketActivationPatch *

Responses


organizerEventsEventIdChartsGet

Get chart of tickets flows for the given event


/organizer/events/{eventId}/charts

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/charts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdChartsGetWith:eventId
              completionHandler: ^(OrganizerEventChart output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsEventIdChartsGet(eventId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdChartsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)

            try {
                OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdChartsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event

try {
    $result = $api_instance->organizerEventsEventIdChartsGet($eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdChartsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event

eval { 
    my $result = $api_instance->organizerEventsEventIdChartsGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdChartsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_charts_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdChartsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdChartsOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}/charts

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/charts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdChartsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdChartsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdChartsOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdChartsOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsEventIdChartsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdChartsOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsEventIdChartsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdChartsOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsEventIdChartsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdChartsOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_event_id_charts_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdChartsOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdDesignsGet

Get designs for the given event


/organizer/events/{eventId}/designs

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/designs"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | event id for the given event
        
        try {
            OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | event id for the given event
        
        try {
            OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdDesignsGetWith:eventId
              completionHandler: ^(OrganizerEventDesignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} event id for the given event

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsEventIdDesignsGet(eventId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdDesignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String | event id for the given event (default to null)

            try {
                OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdDesignsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | event id for the given event

try {
    $result = $api_instance->organizerEventsEventIdDesignsGet($eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdDesignsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | event id for the given event

eval { 
    my $result = $api_instance->organizerEventsEventIdDesignsGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdDesignsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_designs_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdDesignsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdDesignsOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}/designs

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/designs"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdDesignsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdDesignsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdDesignsOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdDesignsOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsEventIdDesignsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdDesignsOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsEventIdDesignsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdDesignsOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsEventIdDesignsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdDesignsOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_event_id_designs_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdDesignsOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdGet

Get information about a single event


/organizer/events/{eventId}

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; //  (default to null)

[apiInstance organizerEventsEventIdGetWith:eventId
              completionHandler: ^(OrganizerEventsGetResponseEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsEventIdGet(eventId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)

            try {
                OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | 

try {
    $result = $api_instance->organizerEventsEventIdGet($eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | 

eval { 
    my $result = $api_instance->organizerEventsEventIdGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String |  (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
Required

Responses


organizerEventsEventIdGroupGet

retrieve the EventGroup to which this event belongs to from the given eventId


/organizer/events/{eventId}/group

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/group"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; //  (default to null)

[apiInstance organizerEventsEventIdGroupGetWith:eventId
              completionHandler: ^(OrganizerEventsGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsEventIdGroupGet(eventId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdGroupGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)

            try {
                OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGroupGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | 

try {
    $result = $api_instance->organizerEventsEventIdGroupGet($eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdGroupGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | 

eval { 
    my $result = $api_instance->organizerEventsEventIdGroupGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdGroupGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String |  (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_group_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdGroupGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
Required

Responses


organizerEventsEventIdGroupOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}/group

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/group"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdGroupOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdGroupOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdGroupOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdGroupOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsEventIdGroupOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGroupOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsEventIdGroupOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdGroupOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsEventIdGroupOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdGroupOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_event_id_group_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdGroupOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdOptions(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdOptionsExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // CORS support
                apiInstance.organizerEventsEventIdOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->organizerEventsEventIdOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval { 
    $api_instance->organizerEventsEventIdOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try: 
    # CORS support
    api_instance.organizer_events_event_id_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdOptions: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Name Type Format Description
AccessMinusControlMinusAllowMinusOrigin String
AccessMinusControlMinusAllowMinusMethods String
AccessMinusControlMinusAllowMinusHeaders String

organizerEventsEventIdPatch

Update information about an event, possibility to notify spectators.


/organizer/events/{eventId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}?mustNotifySpectator="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; //  (default to null)
OrganizerEventPatch *organizerEventPatch = ; // 
String *mustNotifySpectator = mustNotifySpectator_example; //  (optional) (default to null)

[apiInstance organizerEventsEventIdPatchWith:eventId
    organizerEventPatch:organizerEventPatch
    mustNotifySpectator:mustNotifySpectator
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} 
var organizerEventPatch = ; // {OrganizerEventPatch} 
var opts = {
  'mustNotifySpectator': mustNotifySpectator_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdPatch(eventId, organizerEventPatch, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var organizerEventPatch = new OrganizerEventPatch(); // OrganizerEventPatch | 
            var mustNotifySpectator = mustNotifySpectator_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | 
$organizerEventPatch = ; // OrganizerEventPatch | 
$mustNotifySpectator = mustNotifySpectator_example; // String | 

try {
    $api_instance->organizerEventsEventIdPatch($eventId, $organizerEventPatch, $mustNotifySpectator);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | 
my $organizerEventPatch = WWW::OPenAPIClient::Object::OrganizerEventPatch->new(); # OrganizerEventPatch | 
my $mustNotifySpectator = mustNotifySpectator_example; # String | 

eval { 
    $api_instance->organizerEventsEventIdPatch(eventId => $eventId, organizerEventPatch => $organizerEventPatch, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String |  (default to null)
organizerEventPatch =  # OrganizerEventPatch | 
mustNotifySpectator = mustNotifySpectator_example # String |  (optional) (default to null)

try: 
    api_instance.organizer_events_event_id_patch(eventId, organizerEventPatch, mustNotifySpectator=mustNotifySpectator)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String
    let organizerEventPatch = ; // OrganizerEventPatch
    let mustNotifySpectator = mustNotifySpectator_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
Required
Body parameters
Name Description
organizerEventPatch *

Query parameters
Name Description
mustNotifySpectator
String

Responses


organizerEventsEventIdQuestionnaireDelete

Delete event health question


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X DELETE\
-H "x-api-key: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire?questionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        Long questionId = 789; // Long | question id of question to delete
        
        try {
            apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        Long questionId = 789; // Long | question id of question to delete
        
        try {
            apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)
Long *questionId = 789; // question id of question to delete (default to null)

[apiInstance organizerEventsEventIdQuestionnaireDeleteWith:eventId
    questionId:questionId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event
var questionId = 789; // {Long} question id of question to delete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdQuestionnaireDelete(eventId, questionId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdQuestionnaireDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)
            var questionId = 789;  // Long | question id of question to delete (default to null)

            try {
                apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdQuestionnaireDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event
$questionId = 789; // Long | question id of question to delete

try {
    $api_instance->organizerEventsEventIdQuestionnaireDelete($eventId, $questionId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event
my $questionId = 789; # Long | question id of question to delete

eval { 
    $api_instance->organizerEventsEventIdQuestionnaireDelete(eventId => $eventId, questionId => $questionId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)
questionId = 789 # Long | question id of question to delete (default to null)

try: 
    api_instance.organizer_events_event_id_questionnaire_delete(eventId, questionId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String
    let questionId = 789; // Long

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdQuestionnaireDelete(eventId, questionId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required
Query parameters
Name Description
questionId*
Long (int64)
question id of question to delete
Required

Responses


organizerEventsEventIdQuestionnaireGet

Get health questionnaire for the given event


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            EventQuestionnaire result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            EventQuestionnaire result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdQuestionnaireGetWith:eventId
              completionHandler: ^(EventQuestionnaire output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsEventIdQuestionnaireGet(eventId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class organizerEventsEventIdQuestionnaireGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)

            try {
                EventQuestionnaire result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdQuestionnaireGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event

try {
    $result = $api_instance->organizerEventsEventIdQuestionnaireGet($eventId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event

eval { 
    my $result = $api_instance->organizerEventsEventIdQuestionnaireGet(eventId => $eventId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_questionnaire_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdQuestionnaireOptions

CORS support

Enable CORS by returning correct headers


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X OPTIONS\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerEventsEventIdQuestionnaireOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireOptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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


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

// CORS support
[apiInstance organizerEventsEventIdQuestionnaireOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];