import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerAccessValidationOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccessValidationOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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();
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerAccessValidationRequest organizerAccessValidationRequest = new OrganizerAccessValidationRequest(); // OrganizerAccessValidationRequest | 

try {
    final result = await api_instance.organizerAccessValidationPost(organizerAccessValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccessValidationPost: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String email = email_example; // String | 

        try {
            apiInstance.organizerAccountDelete(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String email = new String(); // String | 

try {
    final result = await api_instance.organizerAccountDelete(email);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountDelete: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerAccountOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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();
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerAccountRequest organizerAccountRequest = new OrganizerAccountRequest(); // OrganizerAccountRequest | 

try {
    final result = await api_instance.organizerAccountPost(organizerAccountRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountPost: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailMfaInitTotpOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaInitTotpOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 

try {
    final result = await api_instance.organizerAccountsAccountEmailMfaInitTotpOptions(accountEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailMfaInitTotpOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaInitTotpOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerAccountsAccountEmailMfaInitTotpOptionsWith:accountEmail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerAccountsAccountEmailMfaInitTotpOptions(accountEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailMfaInitTotpOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerAccountsAccountEmailMfaInitTotpOptions(accountEmail => $accountEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpOptions: $@\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()
accountEmail = accountEmail_example # String |  (default to null)

try:
    # CORS support
    api_instance.organizer_accounts_account_email_mfa_init_totp_options(accountEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerMFAInitRequest organizerMFAInitRequest = ; // OrganizerMFAInitRequest | 

        try {
            OrganizerMFAInitResponse result = apiInstance.organizerAccountsAccountEmailMfaInitTotpPost(accountEmail, organizerMFAInitRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaInitTotpPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 
final OrganizerMFAInitRequest organizerMFAInitRequest = new OrganizerMFAInitRequest(); // OrganizerMFAInitRequest | 

try {
    final result = await api_instance.organizerAccountsAccountEmailMfaInitTotpPost(accountEmail, organizerMFAInitRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpPost: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerMFAInitRequest organizerMFAInitRequest = ; // OrganizerMFAInitRequest | 

        try {
            OrganizerMFAInitResponse result = apiInstance.organizerAccountsAccountEmailMfaInitTotpPost(accountEmail, organizerMFAInitRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaInitTotpPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *accountEmail = accountEmail_example; //  (default to null)
OrganizerMFAInitRequest *organizerMFAInitRequest = ; //  (optional)

[apiInstance organizerAccountsAccountEmailMfaInitTotpPostWith:accountEmail
    organizerMFAInitRequest:organizerMFAInitRequest
              completionHandler: ^(OrganizerMFAInitResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 
var opts = {
  'organizerMFAInitRequest':  // {OrganizerMFAInitRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)
            var organizerMFAInitRequest = new OrganizerMFAInitRequest(); // OrganizerMFAInitRequest |  (optional) 

            try {
                OrganizerMFAInitResponse result = apiInstance.organizerAccountsAccountEmailMfaInitTotpPost(accountEmail, organizerMFAInitRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailMfaInitTotpPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$accountEmail = accountEmail_example; // String | 
$organizerMFAInitRequest = ; // OrganizerMFAInitRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $accountEmail = accountEmail_example; # String | 
my $organizerMFAInitRequest = WWW::OPenAPIClient::Object::OrganizerMFAInitRequest->new(); # OrganizerMFAInitRequest | 

eval {
    my $result = $api_instance->organizerAccountsAccountEmailMfaInitTotpPost(accountEmail => $accountEmail, organizerMFAInitRequest => $organizerMFAInitRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpPost: $@\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()
accountEmail = accountEmail_example # String |  (default to null)
organizerMFAInitRequest =  # OrganizerMFAInitRequest |  (optional)

try:
    api_response = api_instance.organizer_accounts_account_email_mfa_init_totp_post(accountEmail, organizerMFAInitRequest=organizerMFAInitRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailMfaInitTotpPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String
    let organizerMFAInitRequest = ; // OrganizerMFAInitRequest

    let mut context = DefaultApi::Context::default();
    let result = client.organizerAccountsAccountEmailMfaInitTotpPost(accountEmail, organizerMFAInitRequest, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailMfaVerifyTotpOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaVerifyTotpOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 

try {
    final result = await api_instance.organizerAccountsAccountEmailMfaVerifyTotpOptions(accountEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailMfaVerifyTotpOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaVerifyTotpOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerAccountsAccountEmailMfaVerifyTotpOptionsWith:accountEmail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerAccountsAccountEmailMfaVerifyTotpOptions(accountEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailMfaVerifyTotpOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerAccountsAccountEmailMfaVerifyTotpOptions(accountEmail => $accountEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpOptions: $@\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()
accountEmail = accountEmail_example # String |  (default to null)

try:
    # CORS support
    api_instance.organizer_accounts_account_email_mfa_verify_totp_options(accountEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerMFASignInRequest organizerMFASignInRequest = ; // OrganizerMFASignInRequest | 

        try {
            OrganizerMFASignInResponse result = apiInstance.organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail, organizerMFASignInRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaVerifyTotpPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 
final OrganizerMFASignInRequest organizerMFASignInRequest = new OrganizerMFASignInRequest(); // OrganizerMFASignInRequest | 

try {
    final result = await api_instance.organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail, organizerMFASignInRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpPost: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerMFASignInRequest organizerMFASignInRequest = ; // OrganizerMFASignInRequest | 

        try {
            OrganizerMFASignInResponse result = apiInstance.organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail, organizerMFASignInRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailMfaVerifyTotpPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *accountEmail = accountEmail_example; //  (default to null)
OrganizerMFASignInRequest *organizerMFASignInRequest = ; //  (optional)

[apiInstance organizerAccountsAccountEmailMfaVerifyTotpPostWith:accountEmail
    organizerMFASignInRequest:organizerMFASignInRequest
              completionHandler: ^(OrganizerMFASignInResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 
var opts = {
  'organizerMFASignInRequest':  // {OrganizerMFASignInRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)
            var organizerMFASignInRequest = new OrganizerMFASignInRequest(); // OrganizerMFASignInRequest |  (optional) 

            try {
                OrganizerMFASignInResponse result = apiInstance.organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail, organizerMFASignInRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailMfaVerifyTotpPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$accountEmail = accountEmail_example; // String | 
$organizerMFASignInRequest = ; // OrganizerMFASignInRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $accountEmail = accountEmail_example; # String | 
my $organizerMFASignInRequest = WWW::OPenAPIClient::Object::OrganizerMFASignInRequest->new(); # OrganizerMFASignInRequest | 

eval {
    my $result = $api_instance->organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail => $accountEmail, organizerMFASignInRequest => $organizerMFASignInRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpPost: $@\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()
accountEmail = accountEmail_example # String |  (default to null)
organizerMFASignInRequest =  # OrganizerMFASignInRequest |  (optional)

try:
    api_response = api_instance.organizer_accounts_account_email_mfa_verify_totp_post(accountEmail, organizerMFASignInRequest=organizerMFASignInRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailMfaVerifyTotpPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String
    let organizerMFASignInRequest = ; // OrganizerMFASignInRequest

    let mut context = DefaultApi::Context::default();
    let result = client.organizerAccountsAccountEmailMfaVerifyTotpPost(accountEmail, organizerMFASignInRequest, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 

try {
    final result = await api_instance.organizerAccountsAccountEmailOptions(accountEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 

        try {
            apiInstance.organizerAccountsAccountEmailOptions(accountEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerAccountsAccountEmailOptionsWith:accountEmail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerAccountsAccountEmailOptions(accountEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerAccountsAccountEmailOptions(accountEmail => $accountEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailOptions: $@\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()
accountEmail = accountEmail_example # String |  (default to null)

try:
    # CORS support
    api_instance.organizer_accounts_account_email_options(accountEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerAccountUpdateRequest organizerAccountUpdateRequest = ; // OrganizerAccountUpdateRequest | 

        try {
            OrganizerAccount result = apiInstance.organizerAccountsAccountEmailPut(accountEmail, organizerAccountUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String accountEmail = new String(); // String | 
final OrganizerAccountUpdateRequest organizerAccountUpdateRequest = new OrganizerAccountUpdateRequest(); // OrganizerAccountUpdateRequest | 

try {
    final result = await api_instance.organizerAccountsAccountEmailPut(accountEmail, organizerAccountUpdateRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsAccountEmailPut: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String accountEmail = accountEmail_example; // String | 
        OrganizerAccountUpdateRequest organizerAccountUpdateRequest = ; // OrganizerAccountUpdateRequest | 

        try {
            OrganizerAccount result = apiInstance.organizerAccountsAccountEmailPut(accountEmail, organizerAccountUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsAccountEmailPut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *accountEmail = accountEmail_example; //  (default to null)
OrganizerAccountUpdateRequest *organizerAccountUpdateRequest = ; //  (optional)

[apiInstance organizerAccountsAccountEmailPutWith:accountEmail
    organizerAccountUpdateRequest:organizerAccountUpdateRequest
              completionHandler: ^(OrganizerAccount output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var accountEmail = accountEmail_example; // {String} 
var opts = {
  'organizerAccountUpdateRequest':  // {OrganizerAccountUpdateRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var accountEmail = accountEmail_example;  // String |  (default to null)
            var organizerAccountUpdateRequest = new OrganizerAccountUpdateRequest(); // OrganizerAccountUpdateRequest |  (optional) 

            try {
                OrganizerAccount result = apiInstance.organizerAccountsAccountEmailPut(accountEmail, organizerAccountUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsAccountEmailPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$accountEmail = accountEmail_example; // String | 
$organizerAccountUpdateRequest = ; // OrganizerAccountUpdateRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $accountEmail = accountEmail_example; # String | 
my $organizerAccountUpdateRequest = WWW::OPenAPIClient::Object::OrganizerAccountUpdateRequest->new(); # OrganizerAccountUpdateRequest | 

eval {
    my $result = $api_instance->organizerAccountsAccountEmailPut(accountEmail => $accountEmail, organizerAccountUpdateRequest => $organizerAccountUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountsAccountEmailPut: $@\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()
accountEmail = accountEmail_example # String |  (default to null)
organizerAccountUpdateRequest =  # OrganizerAccountUpdateRequest |  (optional)

try:
    api_response = api_instance.organizer_accounts_account_email_put(accountEmail, organizerAccountUpdateRequest=organizerAccountUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountsAccountEmailPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let accountEmail = accountEmail_example; // String
    let organizerAccountUpdateRequest = ; // OrganizerAccountUpdateRequest

    let mut context = DefaultApi::Context::default();
    let result = client.organizerAccountsAccountEmailPut(accountEmail, organizerAccountUpdateRequest, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 {
            array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerAccountsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsGet: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerAccountsOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerAccountsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerActivationGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerActivationGet: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');
var defaultClient = TixngoRestApiBackendOrganizerApi.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 TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerActivationOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerActivationOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerApikeyGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApikeyGet: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');
var defaultClient = TixngoRestApiBackendOrganizerApi.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 TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerApikeyOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApikeyOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        String key = key_example; // String | 

        try {
            OrganizerApplicationFeatureResponse result = apiInstance.organizerApplicationFeaturesAppIdGet(appId, offset, limit, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String appId = new String(); // String | the app id related to the feature
final Integer offset = new Integer(); // Integer | 
final Integer limit = new Integer(); // Integer | 
final String key = new String(); // String | 

try {
    final result = await api_instance.organizerApplicationFeaturesAppIdGet(appId, offset, limit, key);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationFeaturesAppIdGet: $e\n');
}

import com.secutix.tixngo._legacy.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
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        String key = key_example; // String | 

        try {
            OrganizerApplicationFeatureResponse result = apiInstance.organizerApplicationFeaturesAppIdGet(appId, offset, limit, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}

// 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)
Integer *offset = 56; //  (default to null)
Integer *limit = 56; //  (default to null)
String *key = key_example; //  (optional) (default to null)

[apiInstance organizerApplicationFeaturesAppIdGetWith:appId
    offset:offset
    limit:limit
    key:key
              completionHandler: ^(OrganizerApplicationFeatureResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var appId = appId_example; // {String} the app id related to the feature
var offset = 56; // {Integer} 
var limit = 56; // {Integer} 
var opts = {
  '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.organizerApplicationFeaturesAppIdGet(appId, 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 organizerApplicationFeaturesAppIdGetExample
    {
        public void main()
        {

            // 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 offset = 56;  // Integer |  (default to null)
            var limit = 56;  // Integer |  (default to null)
            var key = key_example;  // String |  (optional)  (default to null)

            try {
                OrganizerApplicationFeatureResponse result = apiInstance.organizerApplicationFeaturesAppIdGet(appId, offset, limit, key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdGet: " + e.Message );
            }
        }
    }
}

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

// 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
$offset = 56; // Integer | 
$limit = 56; // Integer | 
$key = key_example; // String | 

try {
    $result = $api_instance->organizerApplicationFeaturesAppIdGet($appId, $offset, $limit, $key);
    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;

# 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 $offset = 56; # Integer | 
my $limit = 56; # Integer | 
my $key = key_example; # String | 

eval {
    my $result = $api_instance->organizerApplicationFeaturesAppIdGet(appId => $appId, offset => $offset, limit => $limit, key => $key);
    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

# 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)
offset = 56 # Integer |  (default to null)
limit = 56 # Integer |  (default to null)
key = key_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_application_features_app_id_get(appId, offset, limit, key=key)
    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 offset = 56; // Integer
    let limit = 56; // Integer
    let key = key_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature

        try {
            apiInstance.organizerApplicationFeaturesAppIdOptions(appId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String appId = new String(); // String | the app id related to the feature

try {
    final result = await api_instance.organizerApplicationFeaturesAppIdOptions(appId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationFeaturesAppIdOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 {
            apiInstance.organizerApplicationFeaturesAppIdOptions(appId);
        } 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];
String *appId = appId_example; // the app id related to the feature (default to null)

// CORS support
[apiInstance organizerApplicationFeaturesAppIdOptionsWith:appId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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.');
  }
};
api.organizerApplicationFeaturesAppIdOptions(appId, 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();
            var appId = appId_example;  // String | the app id related to the feature (default to null)

            try {
                // CORS support
                apiInstance.organizerApplicationFeaturesAppIdOptions(appId);
            } 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();
$appId = appId_example; // String | the app id related to the feature

try {
    $api_instance->organizerApplicationFeaturesAppIdOptions($appId);
} 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();
my $appId = appId_example; # String | the app id related to the feature

eval {
    $api_instance->organizerApplicationFeaturesAppIdOptions(appId => $appId);
};
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()
appId = appId_example # String | the app id related to the feature (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String appId = new String(); // String | the app id related to the feature
final array[OrganizerApplicationFeature] organizerApplicationFeature = new array[OrganizerApplicationFeature](); // array[OrganizerApplicationFeature] | 

try {
    final result = await api_instance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 {
            array[AppIdSupportedLanguages] result = apiInstance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[AppIdSupportedLanguages] result = apiInstance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGetWithCompletionHandler: 
              ^(array[AppIdSupportedLanguages] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                array[AppIdSupportedLanguages] result = apiInstance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet: " + 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->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet: ', $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->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet: $@\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_application_settings_all_supported_app_id_supported_languages_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions: " + 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->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions: ', $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->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions: $@\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_all_supported_app_id_supported_languages_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsAllSupportedAppIdSupportedLanguagesOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer offset = new Integer(); // Integer | 
final Integer limit = new Integer(); // Integer | 
final String mobileAppId = new String(); // String | 
final String key = new String(); // String | 

try {
    final result = await api_instance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        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();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *offset = 56; //  (default to null)
Integer *limit = 56; //  (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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var offset = 56; // {Integer} 
var limit = 56; // {Integer} 
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()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = 56;  // Integer |  (default to null)
            var limit = 56;  // Integer |  (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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = 56; // Integer | 
$limit = 56; // Integer | 
$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;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $offset = 56; # Integer | 
my $limit = 56; # Integer | 
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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
offset = 56 # Integer |  (default to null)
limit = 56 # Integer |  (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 = 56; // Integer
    let limit = 56; // Integer
    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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        String configType = configType_example; // String | The configuration type to filter out the result
        Integer offset = 56; // Integer | Offset used for pagination
        Integer limit = 56; // Integer | Limit used for pagination
        String searchKey = searchKey_example; // String | Filtering by key. Used for searching

        try {
            ApplicationSettingsGetResponse result = apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId, configType, offset, limit, searchKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdConfigTypeGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | the app id related to the feature
final String configType = new String(); // String | The configuration type to filter out the result
final Integer offset = new Integer(); // Integer | Offset used for pagination
final Integer limit = new Integer(); // Integer | Limit used for pagination
final String searchKey = new String(); // String | Filtering by key. Used for searching

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId, configType, offset, limit, searchKey);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        String configType = configType_example; // String | The configuration type to filter out the result
        Integer offset = 56; // Integer | Offset used for pagination
        Integer limit = 56; // Integer | Limit used for pagination
        String searchKey = searchKey_example; // String | Filtering by key. Used for searching

        try {
            ApplicationSettingsGetResponse result = apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId, configType, offset, limit, searchKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdConfigTypeGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; // the app id related to the feature (default to null)
String *configType = configType_example; // The configuration type to filter out the result (default to null)
Integer *offset = 56; // Offset used for pagination (default to null)
Integer *limit = 56; // Limit used for pagination (default to null)
String *searchKey = searchKey_example; // Filtering by key. Used for searching (optional) (default to null)

[apiInstance organizerApplicationSettingsMobileAppIdConfigTypeGetWith:mobileAppId
    configType:configType
    offset:offset
    limit:limit
    searchKey:searchKey
              completionHandler: ^(ApplicationSettingsGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} the app id related to the feature
var configType = configType_example; // {String} The configuration type to filter out the result
var offset = 56; // {Integer} Offset used for pagination
var limit = 56; // {Integer} Limit used for pagination
var opts = {
  'searchKey': searchKey_example // {String} Filtering by key. Used for searching
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId, configType, 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 organizerApplicationSettingsMobileAppIdConfigTypeGetExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String | the app id related to the feature (default to null)
            var configType = configType_example;  // String | The configuration type to filter out the result (default to null)
            var offset = 56;  // Integer | Offset used for pagination (default to null)
            var limit = 56;  // Integer | Limit used for pagination (default to null)
            var searchKey = searchKey_example;  // String | Filtering by key. Used for searching (optional)  (default to null)

            try {
                ApplicationSettingsGetResponse result = apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId, configType, offset, limit, searchKey);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdConfigTypeGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mobileAppId = mobileAppId_example; // String | the app id related to the feature
$configType = configType_example; // String | The configuration type to filter out the result
$offset = 56; // Integer | Offset used for pagination
$limit = 56; // Integer | Limit used for pagination
$searchKey = searchKey_example; // String | Filtering by key. Used for searching

try {
    $result = $api_instance->organizerApplicationSettingsMobileAppIdConfigTypeGet($mobileAppId, $configType, $offset, $limit, $searchKey);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $mobileAppId = mobileAppId_example; # String | the app id related to the feature
my $configType = configType_example; # String | The configuration type to filter out the result
my $offset = 56; # Integer | Offset used for pagination
my $limit = 56; # Integer | Limit used for pagination
my $searchKey = searchKey_example; # String | Filtering by key. Used for searching

eval {
    my $result = $api_instance->organizerApplicationSettingsMobileAppIdConfigTypeGet(mobileAppId => $mobileAppId, configType => $configType, offset => $offset, limit => $limit, searchKey => $searchKey);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeGet: $@\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()
mobileAppId = mobileAppId_example # String | the app id related to the feature (default to null)
configType = configType_example # String | The configuration type to filter out the result (default to null)
offset = 56 # Integer | Offset used for pagination (default to null)
limit = 56 # Integer | Limit used for pagination (default to null)
searchKey = searchKey_example # String | Filtering by key. Used for searching (optional) (default to null)

try:
    api_response = api_instance.organizer_application_settings_mobile_app_id_config_type_get(mobileAppId, configType, offset, limit, searchKey=searchKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String
    let configType = configType_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer
    let searchKey = searchKey_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        String configType = configType_example; // String | The configuration type to filter out the result

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeOptions(mobileAppId, configType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdConfigTypeOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | the app id related to the feature
final String configType = new String(); // String | The configuration type to filter out the result

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdConfigTypeOptions(mobileAppId, configType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        String configType = configType_example; // String | The configuration type to filter out the result

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeOptions(mobileAppId, configType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdConfigTypeOptions");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; // the app id related to the feature (default to null)
String *configType = configType_example; // The configuration type to filter out the result (default to null)

// CORS support
[apiInstance organizerApplicationSettingsMobileAppIdConfigTypeOptionsWith:mobileAppId
    configType:configType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} the app id related to the feature
var configType = configType_example; // {String} The configuration type to filter out the result

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String | the app id related to the feature (default to null)
            var configType = configType_example;  // String | The configuration type to filter out the result (default to null)

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsMobileAppIdConfigTypeOptions(mobileAppId, configType);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdConfigTypeOptions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mobileAppId = mobileAppId_example; // String | the app id related to the feature
$configType = configType_example; // String | The configuration type to filter out the result

try {
    $api_instance->organizerApplicationSettingsMobileAppIdConfigTypeOptions($mobileAppId, $configType);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeOptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $mobileAppId = mobileAppId_example; # String | the app id related to the feature
my $configType = configType_example; # String | The configuration type to filter out the result

eval {
    $api_instance->organizerApplicationSettingsMobileAppIdConfigTypeOptions(mobileAppId => $mobileAppId, configType => $configType);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeOptions: $@\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()
mobileAppId = mobileAppId_example # String | the app id related to the feature (default to null)
configType = configType_example # String | The configuration type to filter out the result (default to null)

try:
    # CORS support
    api_instance.organizer_application_settings_mobile_app_id_config_type_options(mobileAppId, configType)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdConfigTypeOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdOptions(mobileAppId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | the app id related to the feature

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdOptions(mobileAppId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdOptions(mobileAppId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerApplicationSettingsMobileAppIdOptionsWith:mobileAppId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var mobileAppId = mobileAppId_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.');
  }
};
api.organizerApplicationSettingsMobileAppIdOptions(mobileAppId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String | the app id related to the feature (default to null)

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsMobileAppIdOptions(mobileAppId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerApplicationSettingsMobileAppIdOptions(mobileAppId => $mobileAppId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdOptions: $@\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()
mobileAppId = mobileAppId_example # String | the app id related to the feature (default to null)

try:
    # CORS support
    api_instance.organizer_application_settings_mobile_app_id_options(mobileAppId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        ApplicationSettingsPatchRequest applicationSettingsPatchRequest = ; // ApplicationSettingsPatchRequest | 

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdPut(mobileAppId, applicationSettingsPatchRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | the app id related to the feature
final ApplicationSettingsPatchRequest applicationSettingsPatchRequest = new ApplicationSettingsPatchRequest(); // ApplicationSettingsPatchRequest | 

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdPut(mobileAppId, applicationSettingsPatchRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdPut: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | the app id related to the feature
        ApplicationSettingsPatchRequest applicationSettingsPatchRequest = ; // ApplicationSettingsPatchRequest | 

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdPut(mobileAppId, applicationSettingsPatchRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdPut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; // the app id related to the feature (default to null)
ApplicationSettingsPatchRequest *applicationSettingsPatchRequest = ; //  (optional)

[apiInstance organizerApplicationSettingsMobileAppIdPutWith:mobileAppId
    applicationSettingsPatchRequest:applicationSettingsPatchRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} the app id related to the feature
var opts = {
  'applicationSettingsPatchRequest':  // {ApplicationSettingsPatchRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String | the app id related to the feature (default to null)
            var applicationSettingsPatchRequest = new ApplicationSettingsPatchRequest(); // ApplicationSettingsPatchRequest |  (optional) 

            try {
                apiInstance.organizerApplicationSettingsMobileAppIdPut(mobileAppId, applicationSettingsPatchRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdPut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->organizerApplicationSettingsMobileAppIdPut($mobileAppId, $applicationSettingsPatchRequest);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerApplicationSettingsMobileAppIdPut(mobileAppId => $mobileAppId, applicationSettingsPatchRequest => $applicationSettingsPatchRequest);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdPut: $@\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()
mobileAppId = mobileAppId_example # String | the app id related to the feature (default to null)
applicationSettingsPatchRequest =  # ApplicationSettingsPatchRequest |  (optional)

try:
    api_instance.organizer_application_settings_mobile_app_id_put(mobileAppId, applicationSettingsPatchRequest=applicationSettingsPatchRequest)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdPut: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 

try {
    final result = await api_instance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 

        try {
            apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId);
        } 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];
String *mobileAppId = mobileAppId_example; //  (default to null)

// CORS support
[apiInstance organizerApplicationSettingsMobileAppIdSupportedLanguagesOptionsWith:mobileAppId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId, 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();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId);
            } 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();
$mobileAppId = mobileAppId_example; // String | 

try {
    $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions($mobileAppId);
} 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();
my $mobileAppId = mobileAppId_example; # String | 

eval {
    $api_instance->organizerApplicationSettingsMobileAppIdSupportedLanguagesOptions(mobileAppId => $mobileAppId);
};
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()
mobileAppId = mobileAppId_example # String |  (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerApplicationSettingsOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerApplicationSettingsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerCommunicationResendOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationResendOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerCommunicationResendOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerCommunicationResendOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerCommunicationResendOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationResendOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerCommunicationResendOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerCommunicationResendOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerCommunicationResendOptions: " + 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->organizerCommunicationResendOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerCommunicationResendOptions: ', $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->organizerCommunicationResendOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerCommunicationResendOptions: $@\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_communication_resend_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerCommunicationResendOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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();
        array[OrganizerCommunicationResendRequest] organizerCommunicationResendRequest = ; // array[OrganizerCommunicationResendRequest] | 

        try {
            apiInstance.organizerCommunicationResendPost(organizerCommunicationResendRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationResendPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[OrganizerCommunicationResendRequest] organizerCommunicationResendRequest = new array[OrganizerCommunicationResendRequest](); // array[OrganizerCommunicationResendRequest] | 

try {
    final result = await api_instance.organizerCommunicationResendPost(organizerCommunicationResendRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerCommunicationResendPost: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[OrganizerCommunicationResendRequest] organizerCommunicationResendRequest = ; // array[OrganizerCommunicationResendRequest] | 

        try {
            apiInstance.organizerCommunicationResendPost(organizerCommunicationResendRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationResendPost");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerCommunicationResendPostWith:organizerCommunicationResendRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var organizerCommunicationResendRequest = ; // {array[OrganizerCommunicationResendRequest]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerCommunicationResendRequest = new array[OrganizerCommunicationResendRequest](); // array[OrganizerCommunicationResendRequest] | 

            try {
                apiInstance.organizerCommunicationResendPost(organizerCommunicationResendRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerCommunicationResendPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$organizerCommunicationResendRequest = ; // array[OrganizerCommunicationResendRequest] | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $organizerCommunicationResendRequest = [WWW::OPenAPIClient::Object::array[OrganizerCommunicationResendRequest]->new()]; # array[OrganizerCommunicationResendRequest] | 

eval {
    $api_instance->organizerCommunicationResendPost(organizerCommunicationResendRequest => $organizerCommunicationResendRequest);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerCommunicationResendPost: $@\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()
organizerCommunicationResendRequest =  # array[OrganizerCommunicationResendRequest] | 

try:
    api_instance.organizer_communication_resend_post(organizerCommunicationResendRequest)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerCommunicationResendPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let organizerCommunicationResendRequest = ; // array[OrganizerCommunicationResendRequest]

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String email = email_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        Date from = 2013-10-20T19:20:30+01:00; // Date | 
        Date to = 2013-10-20T19:20:30+01:00; // Date | 

        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, mobileAppId, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String limit = new String(); // String | 
final String offset = new String(); // String | 
final String email = new String(); // String | 
final String mobileAppId = new String(); // String | 
final String phoneNumber = new String(); // String | 
final String type = new String(); // String | 
final String status = new String(); // String | 
final Date from = new Date(); // Date | 
final Date to = new Date(); // Date | 

try {
    final result = await api_instance.organizerCommunicationsGet(limit, offset, email, mobileAppId, phoneNumber, type, status, from, to);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerCommunicationsGet: $e\n');
}

import com.secutix.tixngo._legacy.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 mobileAppId = mobileAppId_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        Date from = 2013-10-20T19:20:30+01:00; // Date | 
        Date to = 2013-10-20T19:20:30+01:00; // Date | 

        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, mobileAppId, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}

// 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 *mobileAppId = mobileAppId_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)
Date *from = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *to = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)

[apiInstance organizerCommunicationsGetWith:limit
    offset:offset
    email:email
    mobileAppId:mobileAppId
    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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var limit = limit_example; // {String} 
var offset = offset_example; // {String} 
var opts = {
  'email': email_example, // {String} 
  'mobileAppId': mobileAppId_example, // {String} 
  'phoneNumber': phoneNumber_example, // {String} 
  'type': type_example, // {String} 
  'status': status_example, // {String} 
  'from': 2013-10-20T19:20:30+01:00, // {Date} 
  'to': 2013-10-20T19:20:30+01:00 // {Date} 
};

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()
        {

            // 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 mobileAppId = mobileAppId_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 = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var to = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)

            try {
                OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, mobileAppId, 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');

// 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 | 
$mobileAppId = mobileAppId_example; // String | 
$phoneNumber = phoneNumber_example; // String | 
$type = type_example; // String | 
$status = status_example; // String | 
$from = 2013-10-20T19:20:30+01:00; // Date | 
$to = 2013-10-20T19:20:30+01:00; // Date | 

try {
    $result = $api_instance->organizerCommunicationsGet($limit, $offset, $email, $mobileAppId, $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;

# 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 $mobileAppId = mobileAppId_example; # String | 
my $phoneNumber = phoneNumber_example; # String | 
my $type = type_example; # String | 
my $status = status_example; # String | 
my $from = 2013-10-20T19:20:30+01:00; # Date | 
my $to = 2013-10-20T19:20:30+01:00; # Date | 

eval {
    my $result = $api_instance->organizerCommunicationsGet(limit => $limit, offset => $offset, email => $email, mobileAppId => $mobileAppId, 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

# 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)
mobileAppId = mobileAppId_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 = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
to = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)

try:
    api_response = api_instance.organizer_communications_get(limit, offset, email=email, mobileAppId=mobileAppId, 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 mobileAppId = mobileAppId_example; // String
    let phoneNumber = phoneNumber_example; // String
    let type = type_example; // String
    let status = status_example; // String
    let from = 2013-10-20T19:20:30+01:00; // Date
    let to = 2013-10-20T19:20:30+01:00; // Date

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerCommunicationsOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerCommunicationsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerConfigGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerConfigGet: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerConfigOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerConfigOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 {
            OrganizerUIConfigSettings result = apiInstance.organizerConfigUiGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigUiGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerConfigUiGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerConfigUiGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

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

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

[apiInstance organizerConfigUiGetWithCompletionHandler: 
              ^(OrganizerUIConfigSettings output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                OrganizerUIConfigSettings result = apiInstance.organizerConfigUiGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerConfigUiGet: " + 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->organizerConfigUiGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerConfigUiGet: ', $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->organizerConfigUiGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerConfigUiGet: $@\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_ui_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerConfigUiGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerConfigUiOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigUiOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerConfigUiOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerConfigUiOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerConfigUiOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigUiOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerConfigUiOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerConfigUiOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerConfigUiOptions: " + 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->organizerConfigUiOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerConfigUiOptions: ', $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->organizerConfigUiOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerConfigUiOptions: $@\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_ui_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerConfigUiOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String spectatorEmail = spectatorEmail_example; // String | 

        try {
            apiInstance.organizerDevicesMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerDevicesMobileAppIdSpectatorEmailDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 
final String spectatorEmail = new String(); // String | 

try {
    final result = await api_instance.organizerDevicesMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailDelete: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String spectatorEmail = spectatorEmail_example; // String | 

        try {
            apiInstance.organizerDevicesMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerDevicesMobileAppIdSpectatorEmailDelete");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerDevicesMobileAppIdSpectatorEmailDeleteWith:mobileAppId
    spectatorEmail:spectatorEmail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var spectatorEmail = spectatorEmail_example;  // String |  (default to null)

            try {
                apiInstance.organizerDevicesMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerDevicesMobileAppIdSpectatorEmailDelete: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->organizerDevicesMobileAppIdSpectatorEmailDelete($mobileAppId, $spectatorEmail);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerDevicesMobileAppIdSpectatorEmailDelete(mobileAppId => $mobileAppId, spectatorEmail => $spectatorEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailDelete: $@\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()
mobileAppId = mobileAppId_example # String |  (default to null)
spectatorEmail = spectatorEmail_example # String |  (default to null)

try:
    api_instance.organizer_devices_mobile_app_id_spectator_email_delete(mobileAppId, spectatorEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailDelete: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String spectatorEmail = spectatorEmail_example; // String | 

        try {
            apiInstance.organizerDevicesMobileAppIdSpectatorEmailOptions(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerDevicesMobileAppIdSpectatorEmailOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 
final String spectatorEmail = new String(); // String | 

try {
    final result = await api_instance.organizerDevicesMobileAppIdSpectatorEmailOptions(mobileAppId, spectatorEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String spectatorEmail = spectatorEmail_example; // String | 

        try {
            apiInstance.organizerDevicesMobileAppIdSpectatorEmailOptions(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerDevicesMobileAppIdSpectatorEmailOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerDevicesMobileAppIdSpectatorEmailOptionsWith:mobileAppId
    spectatorEmail:spectatorEmail
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var spectatorEmail = spectatorEmail_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerDevicesMobileAppIdSpectatorEmailOptions(mobileAppId, spectatorEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerDevicesMobileAppIdSpectatorEmailOptions: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->organizerDevicesMobileAppIdSpectatorEmailOptions($mobileAppId, $spectatorEmail);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailOptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerDevicesMobileAppIdSpectatorEmailOptions(mobileAppId => $mobileAppId, spectatorEmail => $spectatorEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailOptions: $@\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()
mobileAppId = mobileAppId_example # String |  (default to null)
spectatorEmail = spectatorEmail_example # String |  (default to null)

try:
    # CORS support
    api_instance.organizer_devices_mobile_app_id_spectator_email_options(mobileAppId, spectatorEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerDevicesMobileAppIdSpectatorEmailOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 {
            OrganizerEventGroupSummaryList result = apiInstance.organizerEventGroupListGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventGroupListGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventGroupListGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventGroupListGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

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

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

[apiInstance organizerEventGroupListGetWithCompletionHandler: 
              ^(OrganizerEventGroupSummaryList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                OrganizerEventGroupSummaryList result = apiInstance.organizerEventGroupListGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventGroupListGet: " + 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->organizerEventGroupListGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventGroupListGet: ', $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->organizerEventGroupListGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventGroupListGet: $@\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_event_group_list_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventGroupListGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerEventGroupListOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventGroupListOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventGroupListOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventGroupListOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerEventGroupListOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventGroupListOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventGroupListOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerEventGroupListOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventGroupListOptions: " + 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->organizerEventGroupListOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventGroupListOptions: ', $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->organizerEventGroupListOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventGroupListOptions: $@\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_event_group_list_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventGroupListOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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();
        array[String] groups = ; // array[String] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] groups = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerEventSitesGet(groups);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventSitesGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[String] groups = ; // array[String] | 

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

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

[apiInstance organizerEventSitesGetWith:groups
              completionHandler: ^(OrganizerEventSitesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var opts = {
  'groups':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var groups = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                OrganizerEventSitesResponse result = apiInstance.organizerEventSitesGet(groups);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventSitesGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$groups = ; // array[String] | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->organizerEventSitesGet(groups => $groups);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventSitesGet: $@\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()
groups =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.organizer_event_sites_get(groups=groups)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventSitesGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let groups = ; // array[String]

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerEventSitesOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventSitesOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventSitesOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventSitesOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerEventSitesOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventSitesOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventSitesOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerEventSitesOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventSitesOptions: " + 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->organizerEventSitesOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventSitesOptions: ', $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->organizerEventSitesOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventSitesOptions: $@\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_event_sites_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventSitesOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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();
        array[String] groups = ; // array[String] | 
        array[String] sites = ; // array[String] | 

        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet(groups, sites);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] groups = new array[String](); // array[String] | 
final array[String] sites = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerEventsAllGet(groups, sites);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsAllGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        array[String] groups = ; // array[String] | 
        array[String] sites = ; // array[String] | 

        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet(groups, sites);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
array[String] *groups = ; //  (optional) (default to null)
array[String] *sites = ; //  (optional) (default to null)

[apiInstance organizerEventsAllGetWith:groups
    sites:sites
              completionHandler: ^(array[OrganizerAllEventsResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var opts = {
  'groups': , // {array[String]} 
  'sites':  // {array[String]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerEventsAllGet(opts, 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()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var groups = new array[String](); // array[String] |  (optional)  (default to null)
            var sites = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet(groups, sites);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsAllGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$groups = ; // array[String] | 
$sites = ; // array[String] | 

try {
    $result = $api_instance->organizerEventsAllGet($groups, $sites);
    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;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $groups = []; # array[String] | 
my $sites = []; # array[String] | 

eval {
    my $result = $api_instance->organizerEventsAllGet(groups => $groups, sites => $sites);
    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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
groups =  # array[String] |  (optional) (default to null)
sites =  # array[String] |  (optional) (default to null)

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

extern crate DefaultApi;

pub fn main() {
    let groups = ; // array[String]
    let sites = ; // array[String]

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventsAllOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsAllOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String activationId = activationId_example; // String | 
        String eventId = eventId_example; // String | 

        try {
            apiInstance.organizerEventsEventIdActivationIdOptions(activationId, eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String activationId = new String(); // String | 
final String eventId = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdActivationIdOptions(activationId, eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdActivationIdOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 | 

        try {
            apiInstance.organizerEventsEventIdActivationIdOptions(activationId, eventId);
        } 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];
String *activationId = activationId_example; //  (default to null)
String *eventId = eventId_example; //  (default to null)

// CORS support
[apiInstance organizerEventsEventIdActivationIdOptionsWith:activationId
    eventId:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdActivationIdOptions(activationId, eventId, 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();
            var activationId = activationId_example;  // String |  (default to null)
            var eventId = eventId_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdActivationIdOptions(activationId, eventId);
            } 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();
$activationId = activationId_example; // String | 
$eventId = eventId_example; // String | 

try {
    $api_instance->organizerEventsEventIdActivationIdOptions($activationId, $eventId);
} 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();
my $activationId = activationId_example; # String | 
my $eventId = eventId_example; # String | 

eval {
    $api_instance->organizerEventsEventIdActivationIdOptions(activationId => $activationId, eventId => $eventId);
};
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()
activationId = activationId_example # String |  (default to null)
eventId = eventId_example # String |  (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String activationId = new String(); // String | 
final String eventId = new String(); // String | 
final OrganizerTicketActivationPatch organizerTicketActivationPatch = new OrganizerTicketActivationPatch(); // OrganizerTicketActivationPatch | 

try {
    final result = await api_instance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event

try {
    final result = await api_instance.organizerEventsEventIdChartsGet(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdChartsGet: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event

        try {
            apiInstance.organizerEventsEventIdChartsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event

try {
    final result = await api_instance.organizerEventsEventIdChartsOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdChartsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 {
            apiInstance.organizerEventsEventIdChartsOptions(eventId);
        } 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];
String *eventId = tixngo-league; // event id for the given event (default to null)

// CORS support
[apiInstance organizerEventsEventIdChartsOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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.');
  }
};
api.organizerEventsEventIdChartsOptions(eventId, 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();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdChartsOptions(eventId);
            } 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();
$eventId = tixngo-league; // String | event id for the given event

try {
    $api_instance->organizerEventsEventIdChartsOptions($eventId);
} 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();
my $eventId = tixngo-league; # String | event id for the given event

eval {
    $api_instance->organizerEventsEventIdChartsOptions(eventId => $eventId);
};
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()
eventId = tixngo-league # String | event id for the given event (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event

try {
    final result = await api_instance.organizerEventsEventIdDesignsGet(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdDesignsGet: $e\n');
}

import com.secutix.tixngo._legacy.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();
        }
    }
}

// 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 TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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()
        {

            // 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');

// 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;

# 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

# 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);
}

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | event id for the given event

        try {
            apiInstance.organizerEventsEventIdDesignsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event

try {
    final result = await api_instance.organizerEventsEventIdDesignsOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdDesignsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 {
            apiInstance.organizerEventsEventIdDesignsOptions(eventId);
        } 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];
String *eventId = eventId_example; // event id for the given event (default to null)

// CORS support
[apiInstance organizerEventsEventIdDesignsOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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.');
  }
};
api.organizerEventsEventIdDesignsOptions(eventId, 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();
            var eventId = eventId_example;  // String | event id for the given event (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdDesignsOptions(eventId);
            } 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();
$eventId = eventId_example; // String | event id for the given event

try {
    $api_instance->organizerEventsEventIdDesignsOptions($eventId);
} 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();
my $eventId = eventId_example; # String | event id for the given event

eval {
    $api_instance->organizerEventsEventIdDesignsOptions(eventId => $eventId);
};
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()
eventId = eventId_example # String | event id for the given event (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final String language = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdGet(eventId, language);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdGetWith:eventId
    language:language
              completionHandler: ^(OrganizerEventsGetResponseEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  'language': language_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, opts, 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()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId, language);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerEventsEventIdGet($eventId, $language);
    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;

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

eval {
    my $result = $api_instance->organizerEventsEventIdGet(eventId => $eventId, language => $language);
    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

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

try:
    api_response = api_instance.organizer_events_event_id_get(eventId, language=language)
    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 language = language_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final String language = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdGroupGet(eventId, language);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdGroupGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdGroupGetWith:eventId
    language:language
              completionHandler: ^(OrganizerEventsGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  'language': language_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, opts, 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()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                OrganizerEventsGroup result = apiInstance.organizerEventsEventIdGroupGet(eventId, language);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGroupGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerEventsEventIdGroupGet($eventId, $language);
    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;

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

eval {
    my $result = $api_instance->organizerEventsEventIdGroupGet(eventId => $eventId, language => $language);
    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

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

try:
    api_response = api_instance.organizer_events_event_id_group_get(eventId, language=language)
    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 language = language_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 

        try {
            apiInstance.organizerEventsEventIdGroupOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGroupOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdGroupOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdGroupOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 

        try {
            apiInstance.organizerEventsEventIdGroupOptions(eventId);
        } 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];
String *eventId = eventId_example; //  (default to null)

// CORS support
[apiInstance organizerEventsEventIdGroupOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdGroupOptions(eventId, 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();
            var eventId = eventId_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdGroupOptions(eventId);
            } 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();
$eventId = eventId_example; // String | 

try {
    $api_instance->organizerEventsEventIdGroupOptions($eventId);
} 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();
my $eventId = eventId_example; # String | 

eval {
    $api_instance->organizerEventsEventIdGroupOptions(eventId => $eventId);
};
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()
eventId = eventId_example # String |  (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 

        try {
            apiInstance.organizerEventsEventIdOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 

        try {
            apiInstance.organizerEventsEventIdOptions(eventId);
        } 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];
String *eventId = eventId_example; //  (default to null)

// CORS support
[apiInstance organizerEventsEventIdOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.organizerEventsEventIdOptions(eventId, 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();
            var eventId = eventId_example;  // String |  (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdOptions(eventId);
            } 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();
$eventId = eventId_example; // String | 

try {
    $api_instance->organizerEventsEventIdOptions($eventId);
} 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();
my $eventId = eventId_example; # String | 

eval {
    $api_instance->organizerEventsEventIdOptions(eventId => $eventId);
};
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()
eventId = eventId_example # String |  (default to null)

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 

        try {
            array[OrganizerEventOverrideSettings] result = apiInstance.organizerEventsEventIdOverrideSettingsGet(eventId, mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final String mobileAppId = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdOverrideSettingsGet(eventId, mobileAppId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 

        try {
            array[OrganizerEventOverrideSettings] result = apiInstance.organizerEventsEventIdOverrideSettingsGet(eventId, mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdOverrideSettingsGetWith:eventId
    mobileAppId:mobileAppId
              completionHandler: ^(array[OrganizerEventOverrideSettings] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  '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.organizerEventsEventIdOverrideSettingsGet(eventId, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var mobileAppId = mobileAppId_example;  // String |  (optional)  (default to null)

            try {
                array[OrganizerEventOverrideSettings] result = apiInstance.organizerEventsEventIdOverrideSettingsGet(eventId, mobileAppId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdOverrideSettingsGet: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->organizerEventsEventIdOverrideSettingsGet(eventId => $eventId, mobileAppId => $mobileAppId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsGet: $@\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()
eventId = eventId_example # String |  (default to null)
mobileAppId = mobileAppId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_events_event_id_override_settings_get(eventId, mobileAppId=mobileAppId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsGet: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | eventId

        try {
            apiInstance.organizerEventsEventIdOverrideSettingsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | eventId

try {
    final result = await api_instance.organizerEventsEventIdOverrideSettingsOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | eventId

        try {
            apiInstance.organizerEventsEventIdOverrideSettingsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventsEventIdOverrideSettingsOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String | eventId (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdOverrideSettingsOptions(eventId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdOverrideSettingsOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerEventsEventIdOverrideSettingsOptions(eventId => $eventId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsOptions: $@\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()
eventId = eventId_example # String | eventId (default to null)

try:
    # CORS support
    api_instance.organizer_events_event_id_override_settings_options(eventId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        array[OrganizerEventEditOverrideSettings] organizerEventEditOverrideSettings = ; // array[OrganizerEventEditOverrideSettings] | 

        try {
            apiInstance.organizerEventsEventIdOverrideSettingsPut(eventId, organizerEventEditOverrideSettings);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final array[OrganizerEventEditOverrideSettings] organizerEventEditOverrideSettings = new array[OrganizerEventEditOverrideSettings](); // array[OrganizerEventEditOverrideSettings] | 

try {
    final result = await api_instance.organizerEventsEventIdOverrideSettingsPut(eventId, organizerEventEditOverrideSettings);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsPut: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        array[OrganizerEventEditOverrideSettings] organizerEventEditOverrideSettings = ; // array[OrganizerEventEditOverrideSettings] | 

        try {
            apiInstance.organizerEventsEventIdOverrideSettingsPut(eventId, organizerEventEditOverrideSettings);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdOverrideSettingsPut");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdOverrideSettingsPutWith:eventId
    organizerEventEditOverrideSettings:organizerEventEditOverrideSettings
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  'organizerEventEditOverrideSettings':  // {array[OrganizerEventEditOverrideSettings]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var organizerEventEditOverrideSettings = new array[OrganizerEventEditOverrideSettings](); // array[OrganizerEventEditOverrideSettings] |  (optional) 

            try {
                apiInstance.organizerEventsEventIdOverrideSettingsPut(eventId, organizerEventEditOverrideSettings);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdOverrideSettingsPut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->organizerEventsEventIdOverrideSettingsPut($eventId, $organizerEventEditOverrideSettings);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerEventsEventIdOverrideSettingsPut(eventId => $eventId, organizerEventEditOverrideSettings => $organizerEventEditOverrideSettings);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsPut: $@\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()
eventId = eventId_example # String |  (default to null)
organizerEventEditOverrideSettings =  # array[OrganizerEventEditOverrideSettings] |  (optional)

try:
    api_instance.organizer_events_event_id_override_settings_put(eventId, organizerEventEditOverrideSettings=organizerEventEditOverrideSettings)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdOverrideSettingsPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String
    let organizerEventEditOverrideSettings = ; // array[OrganizerEventEditOverrideSettings]

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        Boolean mustNotifySpectator = true; // Boolean | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final OrganizerEventPatch organizerEventPatch = new OrganizerEventPatch(); // OrganizerEventPatch | 
final Boolean mustNotifySpectator = new Boolean(); // Boolean | 
final String language = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, language);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdPatch: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        Boolean mustNotifySpectator = true; // Boolean | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdPatchWith:eventId
    organizerEventPatch:organizerEventPatch
    mustNotifySpectator:mustNotifySpectator
    language:language
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var organizerEventPatch = ; // {OrganizerEventPatch} 
var opts = {
  'mustNotifySpectator': true, // {Boolean} 
  'language': language_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()
        {

            // 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 = true;  // Boolean |  (optional)  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, language);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdPatch: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->organizerEventsEventIdPatch($eventId, $organizerEventPatch, $mustNotifySpectator, $language);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerEventsEventIdPatch(eventId => $eventId, organizerEventPatch => $organizerEventPatch, mustNotifySpectator => $mustNotifySpectator, language => $language);
};
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

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

try:
    api_instance.organizer_events_event_id_patch(eventId, organizerEventPatch, mustNotifySpectator=mustNotifySpectator, language=language)
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 = true; // Boolean
    let language = language_example; // String

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final String language = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdReferenceDataTicketDetailsGet(eventId, language);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 

        try {
            OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsGet(eventId, language);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdReferenceDataTicketDetailsGetWith:eventId
    language:language
              completionHandler: ^(OrganizerReferenceDataTicketDetailResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  'language': language_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsGet(eventId, language);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdReferenceDataTicketDetailsGet: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->organizerEventsEventIdReferenceDataTicketDetailsGet(eventId => $eventId, language => $language);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsGet: $@\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()
eventId = eventId_example # String |  (default to null)
language = language_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_events_event_id_reference_data_ticket_details_get(eventId, language=language)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsGet: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | Reference data key

        try {
            apiInstance.organizerEventsEventIdReferenceDataTicketDetailsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | Reference data key

try {
    final result = await api_instance.organizerEventsEventIdReferenceDataTicketDetailsOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | Reference data key

        try {
            apiInstance.organizerEventsEventIdReferenceDataTicketDetailsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventsEventIdReferenceDataTicketDetailsOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String | Reference data key (default to null)

            try {
                // CORS support
                apiInstance.organizerEventsEventIdReferenceDataTicketDetailsOptions(eventId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdReferenceDataTicketDetailsOptions: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerEventsEventIdReferenceDataTicketDetailsOptions(eventId => $eventId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsOptions: $@\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()
eventId = eventId_example # String | Reference data key (default to null)

try:
    # CORS support
    api_instance.organizer_events_event_id_reference_data_ticket_details_options(eventId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 
        OrganizerReferenceDataTicketDetailPutRequest organizerReferenceDataTicketDetailPutRequest = ; // OrganizerReferenceDataTicketDetailPutRequest | 

        try {
            OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsPut(eventId, language, organizerReferenceDataTicketDetailPutRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | 
final String language = new String(); // String | 
final OrganizerReferenceDataTicketDetailPutRequest organizerReferenceDataTicketDetailPutRequest = new OrganizerReferenceDataTicketDetailPutRequest(); // OrganizerReferenceDataTicketDetailPutRequest | 

try {
    final result = await api_instance.organizerEventsEventIdReferenceDataTicketDetailsPut(eventId, language, organizerReferenceDataTicketDetailPutRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsPut: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        String language = language_example; // String | 
        OrganizerReferenceDataTicketDetailPutRequest organizerReferenceDataTicketDetailPutRequest = ; // OrganizerReferenceDataTicketDetailPutRequest | 

        try {
            OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsPut(eventId, language, organizerReferenceDataTicketDetailPutRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdReferenceDataTicketDetailsPut");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerEventsEventIdReferenceDataTicketDetailsPutWith:eventId
    language:language
    organizerReferenceDataTicketDetailPutRequest:organizerReferenceDataTicketDetailPutRequest
              completionHandler: ^(OrganizerReferenceDataTicketDetailResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = eventId_example; // {String} 
var opts = {
  'language': language_example, // {String} 
  'organizerReferenceDataTicketDetailPutRequest':  // {OrganizerReferenceDataTicketDetailPutRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)
            var organizerReferenceDataTicketDetailPutRequest = new OrganizerReferenceDataTicketDetailPutRequest(); // OrganizerReferenceDataTicketDetailPutRequest |  (optional) 

            try {
                OrganizerReferenceDataTicketDetailResponse result = apiInstance.organizerEventsEventIdReferenceDataTicketDetailsPut(eventId, language, organizerReferenceDataTicketDetailPutRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdReferenceDataTicketDetailsPut: " + e.Message );
            }
        }
    }
}

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

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

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    my $result = $api_instance->organizerEventsEventIdReferenceDataTicketDetailsPut(eventId => $eventId, language => $language, organizerReferenceDataTicketDetailPutRequest => $organizerReferenceDataTicketDetailPutRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsPut: $@\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()
eventId = eventId_example # String |  (default to null)
language = language_example # String |  (optional) (default to null)
organizerReferenceDataTicketDetailPutRequest =  # OrganizerReferenceDataTicketDetailPutRequest |  (optional)

try:
    api_response = api_instance.organizer_events_event_id_reference_data_ticket_details_put(eventId, language=language, organizerReferenceDataTicketDetailPutRequest=organizerReferenceDataTicketDetailPutRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdReferenceDataTicketDetailsPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String
    let language = language_example; // String
    let organizerReferenceDataTicketDetailPutRequest = ; // OrganizerReferenceDataTicketDetailPutRequest

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event

        try {
            apiInstance.organizerEventsEventIdTicketsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event

try {
    final result = await api_instance.organizerEventsEventIdTicketsOptions(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdTicketsOptions: $e\n');
}

import com.secutix.tixngo._legacy.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 {
            apiInstance.organizerEventsEventIdTicketsOptions(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsOptions");
            e.printStackTrace();
        }
    }
}

// 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)

// CORS support
[apiInstance organizerEventsEventIdTicketsOptionsWith:eventId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.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.');
  }
};
api.organizerEventsEventIdTicketsOptions(eventId, callback);

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

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

            // 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 {
                // CORS support
                apiInstance.organizerEventsEventIdTicketsOptions(eventId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdTicketsOptions: " + e.Message );
            }
        }
    }
}

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

// 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 {
    $api_instance->organizerEventsEventIdTicketsOptions($eventId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdTicketsOptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

eval {
    $api_instance->organizerEventsEventIdTicketsOptions(eventId => $eventId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdTicketsOptions: $@\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()
eventId = tixngo-league # String | event id for the given event (default to null)

try:
    # CORS support
    api_instance.organizer_events_event_id_tickets_options(eventId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdTicketsOptions: %s\n" % e)

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        OrganizerEventDetailsRequest organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
        String transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
        Boolean mustNotifySpectator = true; // Boolean | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | event id for the given event
final OrganizerEventDetailsRequest organizerEventDetailsRequest = new OrganizerEventDetailsRequest(); // OrganizerEventDetailsRequest | 
final String transferRulesId = new String(); // String | transfer rules id targets tickets to update, if null all tickets
final Boolean mustNotifySpectator = new Boolean(); // Boolean | 
final String language = new String(); // String | 

try {
    final result = await api_instance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, language);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: $e\n');
}

import com.secutix.tixngo._legacy.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
        OrganizerEventDetailsRequest organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
        String transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
        Boolean mustNotifySpectator = true; // Boolean | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsPatch");
            e.printStackTrace();
        }
    }
}

// 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)
OrganizerEventDetailsRequest *organizerEventDetailsRequest = ; // 
String *transferRulesId = transferRulesId_example; // transfer rules id targets tickets to update, if null all tickets (optional) (default to null)
Boolean *mustNotifySpectator = true; //  (optional) (default to null)
String *language = language_example; //  (optional) (default to null)

[apiInstance organizerEventsEventIdTicketsPatchWith:eventId
    organizerEventDetailsRequest:organizerEventDetailsRequest
    transferRulesId:transferRulesId
    mustNotifySpectator:mustNotifySpectator
    language:language
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event
var organizerEventDetailsRequest = ; // {OrganizerEventDetailsRequest} 
var opts = {
  'transferRulesId': transferRulesId_example, // {String} transfer rules id targets tickets to update, if null all tickets
  'mustNotifySpectator': true, // {Boolean} 
  'language': language_example // {String} 
};

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

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

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

            // 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 organizerEventDetailsRequest = new OrganizerEventDetailsRequest(); // OrganizerEventDetailsRequest | 
            var transferRulesId = transferRulesId_example;  // String | transfer rules id targets tickets to update, if null all tickets (optional)  (default to null)
            var mustNotifySpectator = true;  // Boolean |  (optional)  (default to null)
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, language);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdTicketsPatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event
$organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
$transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
$mustNotifySpectator = true; // Boolean | 
$language = language_example; // String | 

try {
    $api_instance->organizerEventsEventIdTicketsPatch($eventId, $organizerEventDetailsRequest, $transferRulesId, $mustNotifySpectator, $language);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event
my $organizerEventDetailsRequest = WWW::OPenAPIClient::Object::OrganizerEventDetailsRequest->new(); # OrganizerEventDetailsRequest | 
my $transferRulesId = transferRulesId_example; # String | transfer rules id targets tickets to update, if null all tickets
my $mustNotifySpectator = true; # Boolean | 
my $language = language_example; # String | 

eval {
    $api_instance->organizerEventsEventIdTicketsPatch(eventId => $eventId, organizerEventDetailsRequest => $organizerEventDetailsRequest, transferRulesId => $transferRulesId, mustNotifySpectator => $mustNotifySpectator, language => $language);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: $@\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()
eventId = tixngo-league # String | event id for the given event (default to null)
organizerEventDetailsRequest =  # OrganizerEventDetailsRequest | 
transferRulesId = transferRulesId_example # String | transfer rules id targets tickets to update, if null all tickets (optional) (default to null)
mustNotifySpectator = true # Boolean |  (optional) (default to null)
language = language_example # String |  (optional) (default to null)

try:
    api_instance.organizer_events_event_id_tickets_patch(eventId, organizerEventDetailsRequest, transferRulesId=transferRulesId, mustNotifySpectator=mustNotifySpectator, language=language)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String
    let organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest
    let transferRulesId = transferRulesId_example; // String
    let mustNotifySpectator = true; // Boolean
    let language = language_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, language, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startTime = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            array[OrganizerEventExportResponse] result = apiInstance.organizerEventsExportGet(eventName, eventId, eventIds, startTime, filter, dateFrom, dateTo, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventName = new String(); // String | 
final String eventId = new String(); // String | 
final array[String] eventIds = new array[String](); // array[String] | 
final date startTime = new date(); // date | 
final EventFilter filter = new EventFilter(); // EventFilter | 
final Date dateFrom = new Date(); // Date | 
final Date dateTo = new Date(); // Date | 
final array[String] eventGroupIds = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerEventsExportGet(eventName, eventId, eventIds, startTime, filter, dateFrom, dateTo, eventGroupIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsExportGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startTime = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            array[OrganizerEventExportResponse] result = apiInstance.organizerEventsExportGet(eventName, eventId, eventIds, startTime, filter, dateFrom, dateTo, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventName = eventName_example; //  (optional) (default to null)
String *eventId = eventId_example; //  (optional) (default to null)
array[String] *eventIds = ; //  (optional) (default to null)
date *startTime = Thu Feb 20 00:00:00 UTC 2020; //  (optional) (default to null)
EventFilter *filter = ; //  (optional) (default to null)
Date *dateFrom = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *dateTo = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
array[String] *eventGroupIds = ; //  (optional) (default to null)

[apiInstance organizerEventsExportGetWith:eventName
    eventId:eventId
    eventIds:eventIds
    startTime:startTime
    filter:filter
    dateFrom:dateFrom
    dateTo:dateTo
    eventGroupIds:eventGroupIds
              completionHandler: ^(array[OrganizerEventExportResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var opts = {
  'eventName': eventName_example, // {String} 
  'eventId': eventId_example, // {String} 
  'eventIds': , // {array[String]} 
  'startTime': Thu Feb 20 00:00:00 UTC 2020, // {date} 
  'filter': , // {EventFilter} 
  'dateFrom': 2013-10-20T19:20:30+01:00, // {Date} 
  'dateTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'eventGroupIds':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventName = eventName_example;  // String |  (optional)  (default to null)
            var eventId = eventId_example;  // String |  (optional)  (default to null)
            var eventIds = new array[String](); // array[String] |  (optional)  (default to null)
            var startTime = Thu Feb 20 00:00:00 UTC 2020;  // date |  (optional)  (default to null)
            var filter = new EventFilter(); // EventFilter |  (optional)  (default to null)
            var dateFrom = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var dateTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var eventGroupIds = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                array[OrganizerEventExportResponse] result = apiInstance.organizerEventsExportGet(eventName, eventId, eventIds, startTime, filter, dateFrom, dateTo, eventGroupIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsExportGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventName = eventName_example; // String | 
$eventId = eventId_example; // String | 
$eventIds = ; // array[String] | 
$startTime = Thu Feb 20 00:00:00 UTC 2020; // date | 
$filter = ; // EventFilter | 
$dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
$dateTo = 2013-10-20T19:20:30+01:00; // Date | 
$eventGroupIds = ; // array[String] | 

try {
    $result = $api_instance->organizerEventsExportGet($eventName, $eventId, $eventIds, $startTime, $filter, $dateFrom, $dateTo, $eventGroupIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsExportGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventName = eventName_example; # String | 
my $eventId = eventId_example; # String | 
my $eventIds = []; # array[String] | 
my $startTime = Thu Feb 20 00:00:00 UTC 2020; # date | 
my $filter = ; # EventFilter | 
my $dateFrom = 2013-10-20T19:20:30+01:00; # Date | 
my $dateTo = 2013-10-20T19:20:30+01:00; # Date | 
my $eventGroupIds = []; # array[String] | 

eval {
    my $result = $api_instance->organizerEventsExportGet(eventName => $eventName, eventId => $eventId, eventIds => $eventIds, startTime => $startTime, filter => $filter, dateFrom => $dateFrom, dateTo => $dateTo, eventGroupIds => $eventGroupIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsExportGet: $@\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()
eventName = eventName_example # String |  (optional) (default to null)
eventId = eventId_example # String |  (optional) (default to null)
eventIds =  # array[String] |  (optional) (default to null)
startTime = Thu Feb 20 00:00:00 UTC 2020 # date |  (optional) (default to null)
filter =  # EventFilter |  (optional) (default to null)
dateFrom = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
dateTo = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
eventGroupIds =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.organizer_events_export_get(eventName=eventName, eventId=eventId, eventIds=eventIds, startTime=startTime, filter=filter, dateFrom=dateFrom, dateTo=dateTo, eventGroupIds=eventGroupIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsExportGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let eventName = eventName_example; // String
    let eventId = eventId_example; // String
    let eventIds = ; // array[String]
    let startTime = Thu Feb 20 00:00:00 UTC 2020; // date
    let filter = ; // EventFilter
    let dateFrom = 2013-10-20T19:20:30+01:00; // Date
    let dateTo = 2013-10-20T19:20:30+01:00; // Date
    let eventGroupIds = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsExportGet(eventName, eventId, eventIds, startTime, filter, dateFrom, dateTo, eventGroupIds, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean excludeTransferRules = true; // Boolean | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            array[OrganizerEventExportMultilingualsResponse] result = apiInstance.organizerEventsExportMultilingualsGet(eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportMultilingualsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventName = new String(); // String | 
final String eventId = new String(); // String | 
final array[String] eventIds = new array[String](); // array[String] | 
final date startDate = new date(); // date | 
final EventFilter filter = new EventFilter(); // EventFilter | 
final Date dateFrom = new Date(); // Date | 
final Date dateTo = new Date(); // Date | 
final Boolean excludeTransferRules = new Boolean(); // Boolean | 
final array[String] eventGroupIds = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerEventsExportMultilingualsGet(eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsExportMultilingualsGet: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean excludeTransferRules = true; // Boolean | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            array[OrganizerEventExportMultilingualsResponse] result = apiInstance.organizerEventsExportMultilingualsGet(eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportMultilingualsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventName = eventName_example; //  (optional) (default to null)
String *eventId = eventId_example; //  (optional) (default to null)
array[String] *eventIds = ; //  (optional) (default to null)
date *startDate = Thu Feb 20 00:00:00 UTC 2020; //  (optional) (default to null)
EventFilter *filter = ; //  (optional) (default to null)
Date *dateFrom = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *dateTo = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Boolean *excludeTransferRules = true; //  (optional) (default to null)
array[String] *eventGroupIds = ; //  (optional) (default to null)

[apiInstance organizerEventsExportMultilingualsGetWith:eventName
    eventId:eventId
    eventIds:eventIds
    startDate:startDate
    filter:filter
    dateFrom:dateFrom
    dateTo:dateTo
    excludeTransferRules:excludeTransferRules
    eventGroupIds:eventGroupIds
              completionHandler: ^(array[OrganizerEventExportMultilingualsResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var opts = {
  'eventName': eventName_example, // {String} 
  'eventId': eventId_example, // {String} 
  'eventIds': , // {array[String]} 
  'startDate': Thu Feb 20 00:00:00 UTC 2020, // {date} 
  'filter': , // {EventFilter} 
  'dateFrom': 2013-10-20T19:20:30+01:00, // {Date} 
  'dateTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'excludeTransferRules': true, // {Boolean} 
  'eventGroupIds':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventName = eventName_example;  // String |  (optional)  (default to null)
            var eventId = eventId_example;  // String |  (optional)  (default to null)
            var eventIds = new array[String](); // array[String] |  (optional)  (default to null)
            var startDate = Thu Feb 20 00:00:00 UTC 2020;  // date |  (optional)  (default to null)
            var filter = new EventFilter(); // EventFilter |  (optional)  (default to null)
            var dateFrom = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var dateTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var excludeTransferRules = true;  // Boolean |  (optional)  (default to null)
            var eventGroupIds = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                array[OrganizerEventExportMultilingualsResponse] result = apiInstance.organizerEventsExportMultilingualsGet(eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsExportMultilingualsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventName = eventName_example; // String | 
$eventId = eventId_example; // String | 
$eventIds = ; // array[String] | 
$startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
$filter = ; // EventFilter | 
$dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
$dateTo = 2013-10-20T19:20:30+01:00; // Date | 
$excludeTransferRules = true; // Boolean | 
$eventGroupIds = ; // array[String] | 

try {
    $result = $api_instance->organizerEventsExportMultilingualsGet($eventName, $eventId, $eventIds, $startDate, $filter, $dateFrom, $dateTo, $excludeTransferRules, $eventGroupIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsExportMultilingualsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventName = eventName_example; # String | 
my $eventId = eventId_example; # String | 
my $eventIds = []; # array[String] | 
my $startDate = Thu Feb 20 00:00:00 UTC 2020; # date | 
my $filter = ; # EventFilter | 
my $dateFrom = 2013-10-20T19:20:30+01:00; # Date | 
my $dateTo = 2013-10-20T19:20:30+01:00; # Date | 
my $excludeTransferRules = true; # Boolean | 
my $eventGroupIds = []; # array[String] | 

eval {
    my $result = $api_instance->organizerEventsExportMultilingualsGet(eventName => $eventName, eventId => $eventId, eventIds => $eventIds, startDate => $startDate, filter => $filter, dateFrom => $dateFrom, dateTo => $dateTo, excludeTransferRules => $excludeTransferRules, eventGroupIds => $eventGroupIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsExportMultilingualsGet: $@\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()
eventName = eventName_example # String |  (optional) (default to null)
eventId = eventId_example # String |  (optional) (default to null)
eventIds =  # array[String] |  (optional) (default to null)
startDate = Thu Feb 20 00:00:00 UTC 2020 # date |  (optional) (default to null)
filter =  # EventFilter |  (optional) (default to null)
dateFrom = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
dateTo = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
excludeTransferRules = true # Boolean |  (optional) (default to null)
eventGroupIds =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.organizer_events_export_multilinguals_get(eventName=eventName, eventId=eventId, eventIds=eventIds, startDate=startDate, filter=filter, dateFrom=dateFrom, dateTo=dateTo, excludeTransferRules=excludeTransferRules, eventGroupIds=eventGroupIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsExportMultilingualsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let eventName = eventName_example; // String
    let eventId = eventId_example; // String
    let eventIds = ; // array[String]
    let startDate = Thu Feb 20 00:00:00 UTC 2020; // date
    let filter = ; // EventFilter
    let dateFrom = 2013-10-20T19:20:30+01:00; // Date
    let dateTo = 2013-10-20T19:20:30+01:00; // Date
    let excludeTransferRules = true; // Boolean
    let eventGroupIds = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsExportMultilingualsGet(eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds, &context).wait();

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerEventsExportMultilingualsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportMultilingualsOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventsExportMultilingualsOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsExportMultilingualsOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerEventsExportMultilingualsOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportMultilingualsOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventsExportMultilingualsOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerEventsExportMultilingualsOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsExportMultilingualsOptions: " + 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->organizerEventsExportMultilingualsOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsExportMultilingualsOptions: ', $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->organizerEventsExportMultilingualsOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsExportMultilingualsOptions: $@\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_export_multilinguals_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsExportMultilingualsOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo._legacy.*;
import com.secutix.tixngo._legacy.auth.*;
import com.secutix.tixngo._legacy.model.*;
import com.secutix.tixngo._legacy.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.organizerEventsExportOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerEventsExportOptions();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsExportOptions: $e\n');
}

import com.secutix.tixngo._legacy.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.organizerEventsExportOptions();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsExportOptions");
            e.printStackTrace();
        }
    }
}

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

// CORS support
[apiInstance organizerEventsExportOptionsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

            try {
                // CORS support
                apiInstance.organizerEventsExportOptions();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsExportOptions: " + 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->organizerEventsExportOptions();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsExportOptions: ', $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->organizerEventsExportOptions();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsExportOptions: $@\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_export_options()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsExportOptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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