import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.v1.0.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.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 offset = offset_example; // String | 
        String limit = limit_example; // String | 
        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 {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String offset = new String(); // String | 
final String limit = new String(); // String | 
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.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsGet: $e\n');
}

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String 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 {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *offset = offset_example; //  (default to null)
String *limit = limit_example; //  (default to null)
String *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 organizerEventsGetWith:offset
    limit:limit
    eventName:eventName
    eventId:eventId
    eventIds:eventIds
    startDate:startDate
    filter:filter
    dateFrom:dateFrom
    dateTo:dateTo
    excludeTransferRules:excludeTransferRules
    eventGroupIds:eventGroupIds
              completionHandler: ^(OrganizerEventsGetResponse 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 = offset_example; // {String} 
var limit = limit_example; // {String} 
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.organizerEventsGet(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 organizerEventsGetExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = offset_example;  // String |  (default to null)
            var limit = limit_example;  // String |  (default to null)
            var 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 {
                OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = offset_example; // String | 
$limit = limit_example; // String | 
$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->organizerEventsGet($offset, $limit, $eventName, $eventId, $eventIds, $startDate, $filter, $dateFrom, $dateTo, $excludeTransferRules, $eventGroupIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsGet: ', $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 = offset_example; # String | 
my $limit = limit_example; # String | 
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->organizerEventsGet(offset => $offset, limit => $limit, 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->organizerEventsGet: $@\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 = offset_example # String |  (default to null)
limit = limit_example # String |  (default to null)
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_get(offset, limit, 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->organizerEventsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let offset = offset_example; // String
    let limit = limit_example; // String
    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.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrgEventsPostRequest orgEventsPostRequest = ; // OrgEventsPostRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrgEventsPostRequest orgEventsPostRequest = new OrgEventsPostRequest(); // OrgEventsPostRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerEventsPostWith:orgEventsPostRequest
              completionHandler: ^(OrgEventResponse 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 orgEventsPostRequest = ; // {OrgEventsPostRequest} 

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

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

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

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

            try {
                OrgEventResponse result = apiInstance.organizerEventsPost(orgEventsPostRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsPost: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerEventsPost($orgEventsPostRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsPost: ', $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 $orgEventsPostRequest = WWW::OPenAPIClient::Object::OrgEventsPostRequest->new(); # OrgEventsPostRequest | 

eval {
    my $result = $api_instance->organizerEventsPost(orgEventsPostRequest => $orgEventsPostRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsPost: $@\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()
orgEventsPostRequest =  # OrgEventsPostRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let orgEventsPostRequest = ; // OrgEventsPostRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrgEventsPutRequest orgEventsPutRequest = ; // OrgEventsPutRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrgEventsPutRequest orgEventsPutRequest = new OrgEventsPutRequest(); // OrgEventsPutRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerEventsPutWith:orgEventsPutRequest
              completionHandler: ^(OrgEventResponse 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 orgEventsPutRequest = ; // {OrgEventsPutRequest} 

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

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

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

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

            try {
                OrgEventResponse result = apiInstance.organizerEventsPut(orgEventsPutRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsPut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerEventsPut($orgEventsPutRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsPut: ', $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 $orgEventsPutRequest = WWW::OPenAPIClient::Object::OrgEventsPutRequest->new(); # OrgEventsPutRequest | 

eval {
    my $result = $api_instance->organizerEventsPut(orgEventsPutRequest => $orgEventsPutRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsPut: $@\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()
orgEventsPutRequest =  # OrgEventsPutRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let orgEventsPutRequest = ; // OrgEventsPutRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 groupId = groupId_example; // String | 
        OrganizerEventsGroup organizerEventsGroup = ; // OrganizerEventsGroup | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEventsGroup, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerGroupsGroupIdPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String groupId = new String(); // String | 
final OrganizerEventsGroup organizerEventsGroup = new OrganizerEventsGroup(); // OrganizerEventsGroup | 
final String language = new String(); // String | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String groupId = groupId_example; // String | 
        OrganizerEventsGroup organizerEventsGroup = ; // OrganizerEventsGroup | 
        String language = language_example; // String | 

        try {
            apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEventsGroup, language);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerGroupsGroupIdPatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *groupId = groupId_example; //  (default to null)
OrganizerEventsGroup *organizerEventsGroup = ; // 
String *language = language_example; //  (optional) (default to null)

[apiInstance organizerGroupsGroupIdPatchWith:groupId
    organizerEventsGroup:organizerEventsGroup
    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 groupId = groupId_example; // {String} 
var organizerEventsGroup = ; // {OrganizerEventsGroup} 
var opts = {
  'language': language_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var groupId = groupId_example;  // String |  (default to null)
            var organizerEventsGroup = new OrganizerEventsGroup(); // OrganizerEventsGroup | 
            var language = language_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEventsGroup, language);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerGroupsGroupIdPatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$groupId = groupId_example; // String | 
$organizerEventsGroup = ; // OrganizerEventsGroup | 
$language = language_example; // String | 

try {
    $api_instance->organizerGroupsGroupIdPatch($groupId, $organizerEventsGroup, $language);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerGroupsGroupIdPatch: ', $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 $groupId = groupId_example; # String | 
my $organizerEventsGroup = WWW::OPenAPIClient::Object::OrganizerEventsGroup->new(); # OrganizerEventsGroup | 
my $language = language_example; # String | 

eval {
    $api_instance->organizerGroupsGroupIdPatch(groupId => $groupId, organizerEventsGroup => $organizerEventsGroup, language => $language);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerGroupsGroupIdPatch: $@\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()
groupId = groupId_example # String |  (default to null)
organizerEventsGroup =  # OrganizerEventsGroup | 
language = language_example # String |  (optional) (default to null)

try:
    api_instance.organizer_groups_group_id_patch(groupId, organizerEventsGroup, language=language)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerGroupsGroupIdPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let groupId = groupId_example; // String
    let organizerEventsGroup = ; // OrganizerEventsGroup
    let language = language_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerGroupsGroupIdPatch(groupId, organizerEventsGroup, language, &context).wait();

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerInjectionSettingsGetWithCompletionHandler: 
              ^(OrganizerInjectionSettings 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.organizerInjectionSettingsGet(callback);

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 key = key_example; // String | 
        String oldValue = oldValue_example; // String | 
        ApplicationEditableSetting applicationEditableSetting = ; // ApplicationEditableSetting | 

        try {
            apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobileAppIdSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 
final String key = new String(); // String | 
final String oldValue = new String(); // String | 
final ApplicationEditableSetting applicationEditableSetting = new ApplicationEditableSetting(); // ApplicationEditableSetting | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        String oldValue = oldValue_example; // String | 
        ApplicationEditableSetting applicationEditableSetting = ; // ApplicationEditableSetting | 

        try {
            apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobileAppIdSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; //  (default to null)
String *key = key_example; //  (default to null)
String *oldValue = oldValue_example; //  (optional) (default to null)
ApplicationEditableSetting *applicationEditableSetting = ; //  (optional)

[apiInstance organizerMobileAppIdSettingsKeyPatchWith:mobileAppId
    key:key
    oldValue:oldValue
    applicationEditableSetting:applicationEditableSetting
              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 key = key_example; // {String} 
var opts = {
  'oldValue': oldValue_example, // {String} 
  'applicationEditableSetting':  // {ApplicationEditableSetting} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var key = key_example;  // String |  (default to null)
            var oldValue = oldValue_example;  // String |  (optional)  (default to null)
            var applicationEditableSetting = new ApplicationEditableSetting(); // ApplicationEditableSetting |  (optional) 

            try {
                apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerMobileAppIdSettingsKeyPatch: " + 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 | 
$key = key_example; // String | 
$oldValue = oldValue_example; // String | 
$applicationEditableSetting = ; // ApplicationEditableSetting | 

try {
    $api_instance->organizerMobileAppIdSettingsKeyPatch($mobileAppId, $key, $oldValue, $applicationEditableSetting);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: ', $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 $key = key_example; # String | 
my $oldValue = oldValue_example; # String | 
my $applicationEditableSetting = WWW::OPenAPIClient::Object::ApplicationEditableSetting->new(); # ApplicationEditableSetting | 

eval {
    $api_instance->organizerMobileAppIdSettingsKeyPatch(mobileAppId => $mobileAppId, key => $key, oldValue => $oldValue, applicationEditableSetting => $applicationEditableSetting);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: $@\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)
key = key_example # String |  (default to null)
oldValue = oldValue_example # String |  (optional) (default to null)
applicationEditableSetting =  # ApplicationEditableSetting |  (optional)

try:
    api_instance.organizer_mobile_app_id_settings_key_patch(mobileAppId, key, oldValue=oldValue, applicationEditableSetting=applicationEditableSetting)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String
    let key = key_example; // String
    let oldValue = oldValue_example; // String
    let applicationEditableSetting = ; // ApplicationEditableSetting

    let mut context = DefaultApi::Context::default();
    let result = client.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String email = email_example; // String | 
        String os = os_example; // String | 
        String logLevel = logLevel_example; // String | 
        String logType = logType_example; // String | 
        String appName = appName_example; // String | 
        Date from = 2013-10-20T19:20:30+01:00; // Date | 
        Date to = 2013-10-20T19:20:30+01:00; // Date | 
        String message = message_example; // String | 

        try {
            OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobilelogsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String limit = new String(); // String | Set the number of results returned.
final String offset = new String(); // String | Specify the offset of the first hit to return.
final String email = new String(); // String | 
final String os = new String(); // String | 
final String logLevel = new String(); // String | 
final String logType = new String(); // String | 
final String appName = new String(); // String | 
final Date from = new Date(); // Date | 
final Date to = new Date(); // Date | 
final String message = new String(); // String | 

try {
    final result = await api_instance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerMobilelogsGet: $e\n');
}

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String email = email_example; // String | 
        String os = os_example; // String | 
        String logLevel = logLevel_example; // String | 
        String logType = logType_example; // String | 
        String appName = appName_example; // String | 
        Date from = 2013-10-20T19:20:30+01:00; // Date | 
        Date to = 2013-10-20T19:20:30+01:00; // Date | 
        String message = message_example; // String | 

        try {
            OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobilelogsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; // Set the number of results returned. (default to null)
String *offset = offset_example; // Specify the offset of the first hit to return. (default to null)
String *email = email_example; //  (optional) (default to null)
String *os = os_example; //  (optional) (default to null)
String *logLevel = logLevel_example; //  (optional) (default to null)
String *logType = logType_example; //  (optional) (default to null)
String *appName = appName_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)
String *message = message_example; //  (optional) (default to null)

[apiInstance organizerMobilelogsGetWith:limit
    offset:offset
    email:email
    os:os
    logLevel:logLevel
    logType:logType
    appName:appName
    from:from
    to:to
    message:message
              completionHandler: ^(OrganizerMobileLogsSearchResponse 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} Set the number of results returned.
var offset = offset_example; // {String} Specify the offset of the first hit to return.
var opts = {
  'email': email_example, // {String} 
  'os': os_example, // {String} 
  'logLevel': logLevel_example, // {String} 
  'logType': logType_example, // {String} 
  'appName': appName_example, // {String} 
  'from': 2013-10-20T19:20:30+01:00, // {Date} 
  'to': 2013-10-20T19:20:30+01:00, // {Date} 
  'message': message_example // {String} 
};

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String | Set the number of results returned. (default to null)
            var offset = offset_example;  // String | Specify the offset of the first hit to return. (default to null)
            var email = email_example;  // String |  (optional)  (default to null)
            var os = os_example;  // String |  (optional)  (default to null)
            var logLevel = logLevel_example;  // String |  (optional)  (default to null)
            var logType = logType_example;  // String |  (optional)  (default to null)
            var appName = appName_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)
            var message = message_example;  // String |  (optional)  (default to null)

            try {
                OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerMobilelogsGet: " + 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 | Set the number of results returned.
$offset = offset_example; // String | Specify the offset of the first hit to return.
$email = email_example; // String | 
$os = os_example; // String | 
$logLevel = logLevel_example; // String | 
$logType = logType_example; // String | 
$appName = appName_example; // String | 
$from = 2013-10-20T19:20:30+01:00; // Date | 
$to = 2013-10-20T19:20:30+01:00; // Date | 
$message = message_example; // String | 

try {
    $result = $api_instance->organizerMobilelogsGet($limit, $offset, $email, $os, $logLevel, $logType, $appName, $from, $to, $message);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerMobilelogsGet: ', $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 | Set the number of results returned.
my $offset = offset_example; # String | Specify the offset of the first hit to return.
my $email = email_example; # String | 
my $os = os_example; # String | 
my $logLevel = logLevel_example; # String | 
my $logType = logType_example; # String | 
my $appName = appName_example; # String | 
my $from = 2013-10-20T19:20:30+01:00; # Date | 
my $to = 2013-10-20T19:20:30+01:00; # Date | 
my $message = message_example; # String | 

eval {
    my $result = $api_instance->organizerMobilelogsGet(limit => $limit, offset => $offset, email => $email, os => $os, logLevel => $logLevel, logType => $logType, appName => $appName, from => $from, to => $to, message => $message);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerMobilelogsGet: $@\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 | Set the number of results returned. (default to null)
offset = offset_example # String | Specify the offset of the first hit to return. (default to null)
email = email_example # String |  (optional) (default to null)
os = os_example # String |  (optional) (default to null)
logLevel = logLevel_example # String |  (optional) (default to null)
logType = logType_example # String |  (optional) (default to null)
appName = appName_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)
message = message_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_mobilelogs_get(limit, offset, email=email, os=os, logLevel=logLevel, logType=logType, appName=appName, from=from, to=to, message=message)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerMobilelogsGet: %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 os = os_example; // String
    let logLevel = logLevel_example; // String
    let logType = logType_example; // String
    let appName = appName_example; // String
    let from = 2013-10-20T19:20:30+01:00; // Date
    let to = 2013-10-20T19:20:30+01:00; // Date
    let message = message_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        Long campaignId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long campaignId = new Long(); // Long | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Long *campaignId = 789; //  (default to null)

[apiInstance organizerNotificationcampaignCampaignIdDeleteWith:campaignId
              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 campaignId = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var campaignId = 789;  // Long |  (default to null)

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

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

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

try {
    $api_instance->organizerNotificationcampaignCampaignIdDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignCampaignIdDelete: ', $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 $campaignId = 789; # Long | 

eval {
    $api_instance->organizerNotificationcampaignCampaignIdDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignCampaignIdDelete: $@\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()
campaignId = 789 # Long |  (default to null)

try:
    api_instance.organizer_notificationcampaign_campaign_id_delete(campaignId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignCampaignIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let campaignId = 789; // Long

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        Long campaignId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long campaignId = new Long(); // Long | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Long *campaignId = 789; //  (default to null)

[apiInstance organizerNotificationcampaignCampaignIdGetWith:campaignId
              completionHandler: ^(OrganizerNotificationCampaign 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 campaignId = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var campaignId = 789;  // Long |  (default to null)

            try {
                OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignCampaignIdGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignCampaignIdGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerNotificationcampaignCampaignIdGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignCampaignIdGet: ', $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 $campaignId = 789; # Long | 

eval {
    my $result = $api_instance->organizerNotificationcampaignCampaignIdGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignCampaignIdGet: $@\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()
campaignId = 789 # Long |  (default to null)

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

extern crate DefaultApi;

pub fn main() {
    let campaignId = 789; // Long

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerNotificationCampaign organizerNotificationCampaign = new OrganizerNotificationCampaign(); // OrganizerNotificationCampaign | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerNotificationcampaignPatchWith:organizerNotificationCampaign
              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 organizerNotificationCampaign = ; // {OrganizerNotificationCampaign} 

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

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

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

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

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

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

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

try {
    $api_instance->organizerNotificationcampaignPatch($organizerNotificationCampaign);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignPatch: ', $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 $organizerNotificationCampaign = WWW::OPenAPIClient::Object::OrganizerNotificationCampaign->new(); # OrganizerNotificationCampaign | 

eval {
    $api_instance->organizerNotificationcampaignPatch(organizerNotificationCampaign => $organizerNotificationCampaign);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignPatch: $@\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()
organizerNotificationCampaign =  # OrganizerNotificationCampaign | 

try:
    api_instance.organizer_notificationcampaign_patch(organizerNotificationCampaign)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaign = ; // OrganizerNotificationCampaign

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerNotificationCampaign organizerNotificationCampaign = new OrganizerNotificationCampaign(); // OrganizerNotificationCampaign | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerNotificationcampaignPostWith:organizerNotificationCampaign
              completionHandler: ^(OrganizerNotificationCampaign 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 organizerNotificationCampaign = ; // {OrganizerNotificationCampaign} 

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

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

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

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

            try {
                OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignPost(organizerNotificationCampaign);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignPost: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerNotificationcampaignPost($organizerNotificationCampaign);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignPost: ', $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 $organizerNotificationCampaign = WWW::OPenAPIClient::Object::OrganizerNotificationCampaign->new(); # OrganizerNotificationCampaign | 

eval {
    my $result = $api_instance->organizerNotificationcampaignPost(organizerNotificationCampaign => $organizerNotificationCampaign);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignPost: $@\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()
organizerNotificationCampaign =  # OrganizerNotificationCampaign | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaign = ; // OrganizerNotificationCampaign

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerNotificationCampaign organizerNotificationCampaign = new OrganizerNotificationCampaign(); // OrganizerNotificationCampaign | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerNotificationcampaignPutWith:organizerNotificationCampaign
              completionHandler: ^(OrganizerNotificationCampaign 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 organizerNotificationCampaign = ; // {OrganizerNotificationCampaign} 

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

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

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

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

            try {
                OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignPut(organizerNotificationCampaign);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignPut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerNotificationcampaignPut($organizerNotificationCampaign);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignPut: ', $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 $organizerNotificationCampaign = WWW::OPenAPIClient::Object::OrganizerNotificationCampaign->new(); # OrganizerNotificationCampaign | 

eval {
    my $result = $api_instance->organizerNotificationcampaignPut(organizerNotificationCampaign => $organizerNotificationCampaign);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignPut: $@\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()
organizerNotificationCampaign =  # OrganizerNotificationCampaign | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaign = ; // OrganizerNotificationCampaign

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 campaignId = campaignId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerNotificationcampaignReportCampaignIdGetWith:campaignId
              completionHandler: ^(OrganizerS3Url 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 campaignId = campaignId_example; // {String} 

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

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

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

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

            try {
                OrganizerS3Url result = apiInstance.organizerNotificationcampaignReportCampaignIdGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignReportCampaignIdGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerNotificationcampaignReportCampaignIdGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignReportCampaignIdGet: ', $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 $campaignId = campaignId_example; # String | 

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

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

extern crate DefaultApi;

pub fn main() {
    let campaignId = campaignId_example; // String

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 mobileAppId = mobileAppId_example; // String | 
        String name = name_example; // String | 
        String contentLanguage = contentLanguage_example; // String | 
        CampaignStatusFilter status = ; // CampaignStatusFilter | 

        try {
            OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, mobileAppId, name, contentLanguage, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignReportsGet");
            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 mobileAppId = new String(); // String | 
final String name = new String(); // String | 
final String contentLanguage = new String(); // String | 
final CampaignStatusFilter status = new CampaignStatusFilter(); // CampaignStatusFilter | 

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

import com.secutix.tixngo.v1.0.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 mobileAppId = mobileAppId_example; // String | 
        String name = name_example; // String | 
        String contentLanguage = contentLanguage_example; // String | 
        CampaignStatusFilter status = ; // CampaignStatusFilter | 

        try {
            OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, mobileAppId, name, contentLanguage, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignReportsGet");
            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 *mobileAppId = mobileAppId_example; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *contentLanguage = contentLanguage_example; //  (optional) (default to null)
CampaignStatusFilter *status = ; //  (optional) (default to null)

[apiInstance organizerNotificationcampaignReportsGetWith:limit
    offset:offset
    mobileAppId:mobileAppId
    name:name
    contentLanguage:contentLanguage
    status:status
              completionHandler: ^(OrganizerNotificationCampaignReportResponse 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 mobileAppId = mobileAppId_example; // {String} 
var opts = {
  'name': name_example, // {String} 
  'contentLanguage': contentLanguage_example, // {String} 
  'status':  // {CampaignStatusFilter} 
};

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

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

namespace Example
{
    public class organizerNotificationcampaignReportsGetExample
    {
        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 mobileAppId = mobileAppId_example;  // String |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var contentLanguage = contentLanguage_example;  // String |  (optional)  (default to null)
            var status = new CampaignStatusFilter(); // CampaignStatusFilter |  (optional)  (default to null)

            try {
                OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, mobileAppId, name, contentLanguage, status);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignReportsGet: " + 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 | 
$mobileAppId = mobileAppId_example; // String | 
$name = name_example; // String | 
$contentLanguage = contentLanguage_example; // String | 
$status = ; // CampaignStatusFilter | 

try {
    $result = $api_instance->organizerNotificationcampaignReportsGet($limit, $offset, $mobileAppId, $name, $contentLanguage, $status);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: ', $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 $mobileAppId = mobileAppId_example; # String | 
my $name = name_example; # String | 
my $contentLanguage = contentLanguage_example; # String | 
my $status = ; # CampaignStatusFilter | 

eval {
    my $result = $api_instance->organizerNotificationcampaignReportsGet(limit => $limit, offset => $offset, mobileAppId => $mobileAppId, name => $name, contentLanguage => $contentLanguage, status => $status);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: $@\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)
mobileAppId = mobileAppId_example # String |  (default to null)
name = name_example # String |  (optional) (default to null)
contentLanguage = contentLanguage_example # String |  (optional) (default to null)
status =  # CampaignStatusFilter |  (optional) (default to null)

try:
    api_response = api_instance.organizer_notificationcampaign_reports_get(limit, offset, mobileAppId, name=name, contentLanguage=contentLanguage, status=status)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let mobileAppId = mobileAppId_example; // String
    let name = name_example; // String
    let contentLanguage = contentLanguage_example; // String
    let status = ; // CampaignStatusFilter

    let mut context = DefaultApi::Context::default();
    let result = client.organizerNotificationcampaignReportsGet(limit, offset, mobileAppId, name, contentLanguage, status, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerNotificationCampaignFilterRequest organizerNotificationCampaignFilterRequest = ; // OrganizerNotificationCampaignFilterRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerNotificationCampaignFilterRequest organizerNotificationCampaignFilterRequest = new OrganizerNotificationCampaignFilterRequest(); // OrganizerNotificationCampaignFilterRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerNotificationcampaignTargetsPostWith:organizerNotificationCampaignFilterRequest
              completionHandler: ^(OrganizerNotificationCampaignTargetsResponse 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 organizerNotificationCampaignFilterRequest = ; // {OrganizerNotificationCampaignFilterRequest} 

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

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

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

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

            try {
                OrganizerNotificationCampaignTargetsResponse result = apiInstance.organizerNotificationcampaignTargetsPost(organizerNotificationCampaignFilterRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignTargetsPost: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerNotificationcampaignTargetsPost($organizerNotificationCampaignFilterRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignTargetsPost: ', $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 $organizerNotificationCampaignFilterRequest = WWW::OPenAPIClient::Object::OrganizerNotificationCampaignFilterRequest->new(); # OrganizerNotificationCampaignFilterRequest | 

eval {
    my $result = $api_instance->organizerNotificationcampaignTargetsPost(organizerNotificationCampaignFilterRequest => $organizerNotificationCampaignFilterRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignTargetsPost: $@\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()
organizerNotificationCampaignFilterRequest =  # OrganizerNotificationCampaignFilterRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaignFilterRequest = ; // OrganizerNotificationCampaignFilterRequest

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

        try {
            OrganizerOperatorRole result = apiInstance.organizerOperatorRoleGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerOperatorRoleGet");
            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 organizerOperatorRoleGetWithCompletionHandler: 
              ^(OrganizerOperatorRole 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.organizerOperatorRoleGet(callback);

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

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

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String contains = contains_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String approvedEmail = approvedEmail_example; // String | 
        String triggeringEmail = triggeringEmail_example; // String | 
        String ticketId = ticketId_example; // String | 
        Boolean registered = true; // Boolean | 
        array[String] contingentIds = ; // array[String] | 

        try {
            OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, mobileAppId, approvedEmail, triggeringEmail, ticketId, registered, contingentIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPendingSpectatorsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String limit = new String(); // String | Set the number of results returned.
final String offset = new String(); // String | Specify the offset of the first hit to return.
final String contains = new String(); // String | 
final String mobileAppId = new String(); // String | 
final String approvedEmail = new String(); // String | 
final String triggeringEmail = new String(); // String | 
final String ticketId = new String(); // String | 
final Boolean registered = new Boolean(); // Boolean | 
final array[String] contingentIds = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerPendingSpectatorsGet(limit, offset, contains, mobileAppId, approvedEmail, triggeringEmail, ticketId, registered, contingentIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerPendingSpectatorsGet: $e\n');
}

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String contains = contains_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String approvedEmail = approvedEmail_example; // String | 
        String triggeringEmail = triggeringEmail_example; // String | 
        String ticketId = ticketId_example; // String | 
        Boolean registered = true; // Boolean | 
        array[String] contingentIds = ; // array[String] | 

        try {
            OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, mobileAppId, approvedEmail, triggeringEmail, ticketId, registered, contingentIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPendingSpectatorsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; // Set the number of results returned. (default to null)
String *offset = offset_example; // Specify the offset of the first hit to return. (default to null)
String *contains = contains_example; //  (optional) (default to null)
String *mobileAppId = mobileAppId_example; //  (optional) (default to null)
String *approvedEmail = approvedEmail_example; //  (optional) (default to null)
String *triggeringEmail = triggeringEmail_example; //  (optional) (default to null)
String *ticketId = ticketId_example; //  (optional) (default to null)
Boolean *registered = true; //  (optional) (default to null)
array[String] *contingentIds = ; //  (optional) (default to null)

[apiInstance organizerPendingSpectatorsGetWith:limit
    offset:offset
    contains:contains
    mobileAppId:mobileAppId
    approvedEmail:approvedEmail
    triggeringEmail:triggeringEmail
    ticketId:ticketId
    registered:registered
    contingentIds:contingentIds
              completionHandler: ^(OrganizerPendingSpectatorsSearchResponse 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} Set the number of results returned.
var offset = offset_example; // {String} Specify the offset of the first hit to return.
var opts = {
  'contains': contains_example, // {String} 
  'mobileAppId': mobileAppId_example, // {String} 
  'approvedEmail': approvedEmail_example, // {String} 
  'triggeringEmail': triggeringEmail_example, // {String} 
  'ticketId': ticketId_example, // {String} 
  'registered': true, // {Boolean} 
  'contingentIds':  // {array[String]} 
};

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String | Set the number of results returned. (default to null)
            var offset = offset_example;  // String | Specify the offset of the first hit to return. (default to null)
            var contains = contains_example;  // String |  (optional)  (default to null)
            var mobileAppId = mobileAppId_example;  // String |  (optional)  (default to null)
            var approvedEmail = approvedEmail_example;  // String |  (optional)  (default to null)
            var triggeringEmail = triggeringEmail_example;  // String |  (optional)  (default to null)
            var ticketId = ticketId_example;  // String |  (optional)  (default to null)
            var registered = true;  // Boolean |  (optional)  (default to null)
            var contingentIds = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, mobileAppId, approvedEmail, triggeringEmail, ticketId, registered, contingentIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPendingSpectatorsGet: " + 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 | Set the number of results returned.
$offset = offset_example; // String | Specify the offset of the first hit to return.
$contains = contains_example; // String | 
$mobileAppId = mobileAppId_example; // String | 
$approvedEmail = approvedEmail_example; // String | 
$triggeringEmail = triggeringEmail_example; // String | 
$ticketId = ticketId_example; // String | 
$registered = true; // Boolean | 
$contingentIds = ; // array[String] | 

try {
    $result = $api_instance->organizerPendingSpectatorsGet($limit, $offset, $contains, $mobileAppId, $approvedEmail, $triggeringEmail, $ticketId, $registered, $contingentIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPendingSpectatorsGet: ', $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 | Set the number of results returned.
my $offset = offset_example; # String | Specify the offset of the first hit to return.
my $contains = contains_example; # String | 
my $mobileAppId = mobileAppId_example; # String | 
my $approvedEmail = approvedEmail_example; # String | 
my $triggeringEmail = triggeringEmail_example; # String | 
my $ticketId = ticketId_example; # String | 
my $registered = true; # Boolean | 
my $contingentIds = []; # array[String] | 

eval {
    my $result = $api_instance->organizerPendingSpectatorsGet(limit => $limit, offset => $offset, contains => $contains, mobileAppId => $mobileAppId, approvedEmail => $approvedEmail, triggeringEmail => $triggeringEmail, ticketId => $ticketId, registered => $registered, contingentIds => $contingentIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPendingSpectatorsGet: $@\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 | Set the number of results returned. (default to null)
offset = offset_example # String | Specify the offset of the first hit to return. (default to null)
contains = contains_example # String |  (optional) (default to null)
mobileAppId = mobileAppId_example # String |  (optional) (default to null)
approvedEmail = approvedEmail_example # String |  (optional) (default to null)
triggeringEmail = triggeringEmail_example # String |  (optional) (default to null)
ticketId = ticketId_example # String |  (optional) (default to null)
registered = true # Boolean |  (optional) (default to null)
contingentIds =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.organizer_pending_spectators_get(limit, offset, contains=contains, mobileAppId=mobileAppId, approvedEmail=approvedEmail, triggeringEmail=triggeringEmail, ticketId=ticketId, registered=registered, contingentIds=contingentIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerPendingSpectatorsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let contains = contains_example; // String
    let mobileAppId = mobileAppId_example; // String
    let approvedEmail = approvedEmail_example; // String
    let triggeringEmail = triggeringEmail_example; // String
    let ticketId = ticketId_example; // String
    let registered = true; // Boolean
    let contingentIds = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerPendingSpectatorsGet(limit, offset, contains, mobileAppId, approvedEmail, triggeringEmail, ticketId, registered, contingentIds, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerPrivilegeDefinitionPatchRequest organizerPrivilegeDefinitionPatchRequest = ; // OrganizerPrivilegeDefinitionPatchRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerPrivilegeDefinitionPatchRequest organizerPrivilegeDefinitionPatchRequest = new OrganizerPrivilegeDefinitionPatchRequest(); // OrganizerPrivilegeDefinitionPatchRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerPrivilegeDefinitionPatchWith:organizerPrivilegeDefinitionPatchRequest
              completionHandler: ^(OrganizerPrivilegeDefinitionPatchResponse 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 organizerPrivilegeDefinitionPatchRequest = ; // {OrganizerPrivilegeDefinitionPatchRequest} 

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

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

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

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

            try {
                OrganizerPrivilegeDefinitionPatchResponse result = apiInstance.organizerPrivilegeDefinitionPatch(organizerPrivilegeDefinitionPatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeDefinitionPatch: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerPrivilegeDefinitionPatch($organizerPrivilegeDefinitionPatchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeDefinitionPatch: ', $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 $organizerPrivilegeDefinitionPatchRequest = WWW::OPenAPIClient::Object::OrganizerPrivilegeDefinitionPatchRequest->new(); # OrganizerPrivilegeDefinitionPatchRequest | 

eval {
    my $result = $api_instance->organizerPrivilegeDefinitionPatch(organizerPrivilegeDefinitionPatchRequest => $organizerPrivilegeDefinitionPatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeDefinitionPatch: $@\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()
organizerPrivilegeDefinitionPatchRequest =  # OrganizerPrivilegeDefinitionPatchRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerPrivilegeDefinitionPatchRequest = ; // OrganizerPrivilegeDefinitionPatchRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerPrivilegeDefinitionPostRequest organizerPrivilegeDefinitionPostRequest = ; // OrganizerPrivilegeDefinitionPostRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerPrivilegeDefinitionPostRequest organizerPrivilegeDefinitionPostRequest = new OrganizerPrivilegeDefinitionPostRequest(); // OrganizerPrivilegeDefinitionPostRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerPrivilegeDefinitionPostWith:organizerPrivilegeDefinitionPostRequest
              completionHandler: ^(OrganizerPrivilegeDefinitionPostResponse 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 organizerPrivilegeDefinitionPostRequest = ; // {OrganizerPrivilegeDefinitionPostRequest} 

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

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

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

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

            try {
                OrganizerPrivilegeDefinitionPostResponse result = apiInstance.organizerPrivilegeDefinitionPost(organizerPrivilegeDefinitionPostRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeDefinitionPost: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerPrivilegeDefinitionPost($organizerPrivilegeDefinitionPostRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeDefinitionPost: ', $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 $organizerPrivilegeDefinitionPostRequest = WWW::OPenAPIClient::Object::OrganizerPrivilegeDefinitionPostRequest->new(); # OrganizerPrivilegeDefinitionPostRequest | 

eval {
    my $result = $api_instance->organizerPrivilegeDefinitionPost(organizerPrivilegeDefinitionPostRequest => $organizerPrivilegeDefinitionPostRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeDefinitionPost: $@\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()
organizerPrivilegeDefinitionPostRequest =  # OrganizerPrivilegeDefinitionPostRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerPrivilegeDefinitionPostRequest = ; // OrganizerPrivilegeDefinitionPostRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 operatorEmail = operatorEmail_example; // String | 
        array[String] privilegeSpectatorInstances = ; // array[String] | 
        String reason = reason_example; // String | 
        Boolean showDeletedInstance = true; // Boolean | 

        try {
            OrganizerPrivilegeSpectatorInstanceDeleteResponse result = apiInstance.organizerPrivilegeSpectatorInstanceDelete(operatorEmail, privilegeSpectatorInstances, reason, showDeletedInstance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPrivilegeSpectatorInstanceDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String operatorEmail = new String(); // String | 
final array[String] privilegeSpectatorInstances = new array[String](); // array[String] | 
final String reason = new String(); // String | 
final Boolean showDeletedInstance = new Boolean(); // Boolean | 

try {
    final result = await api_instance.organizerPrivilegeSpectatorInstanceDelete(operatorEmail, privilegeSpectatorInstances, reason, showDeletedInstance);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerPrivilegeSpectatorInstanceDelete: $e\n');
}

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String operatorEmail = operatorEmail_example; // String | 
        array[String] privilegeSpectatorInstances = ; // array[String] | 
        String reason = reason_example; // String | 
        Boolean showDeletedInstance = true; // Boolean | 

        try {
            OrganizerPrivilegeSpectatorInstanceDeleteResponse result = apiInstance.organizerPrivilegeSpectatorInstanceDelete(operatorEmail, privilegeSpectatorInstances, reason, showDeletedInstance);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPrivilegeSpectatorInstanceDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *operatorEmail = operatorEmail_example; //  (default to null)
array[String] *privilegeSpectatorInstances = ; //  (default to null)
String *reason = reason_example; //  (optional) (default to null)
Boolean *showDeletedInstance = true; //  (optional) (default to false)

[apiInstance organizerPrivilegeSpectatorInstanceDeleteWith:operatorEmail
    privilegeSpectatorInstances:privilegeSpectatorInstances
    reason:reason
    showDeletedInstance:showDeletedInstance
              completionHandler: ^(OrganizerPrivilegeSpectatorInstanceDeleteResponse 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 operatorEmail = operatorEmail_example; // {String} 
var privilegeSpectatorInstances = ; // {array[String]} 
var opts = {
  'reason': reason_example, // {String} 
  'showDeletedInstance': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operatorEmail = operatorEmail_example;  // String |  (default to null)
            var privilegeSpectatorInstances = new array[String](); // array[String] |  (default to null)
            var reason = reason_example;  // String |  (optional)  (default to null)
            var showDeletedInstance = true;  // Boolean |  (optional)  (default to false)

            try {
                OrganizerPrivilegeSpectatorInstanceDeleteResponse result = apiInstance.organizerPrivilegeSpectatorInstanceDelete(operatorEmail, privilegeSpectatorInstances, reason, showDeletedInstance);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeSpectatorInstanceDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operatorEmail = operatorEmail_example; // String | 
$privilegeSpectatorInstances = ; // array[String] | 
$reason = reason_example; // String | 
$showDeletedInstance = true; // Boolean | 

try {
    $result = $api_instance->organizerPrivilegeSpectatorInstanceDelete($operatorEmail, $privilegeSpectatorInstances, $reason, $showDeletedInstance);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeSpectatorInstanceDelete: ', $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 $operatorEmail = operatorEmail_example; # String | 
my $privilegeSpectatorInstances = []; # array[String] | 
my $reason = reason_example; # String | 
my $showDeletedInstance = true; # Boolean | 

eval {
    my $result = $api_instance->organizerPrivilegeSpectatorInstanceDelete(operatorEmail => $operatorEmail, privilegeSpectatorInstances => $privilegeSpectatorInstances, reason => $reason, showDeletedInstance => $showDeletedInstance);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeSpectatorInstanceDelete: $@\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()
operatorEmail = operatorEmail_example # String |  (default to null)
privilegeSpectatorInstances =  # array[String] |  (default to null)
reason = reason_example # String |  (optional) (default to null)
showDeletedInstance = true # Boolean |  (optional) (default to false)

try:
    api_response = api_instance.organizer_privilege_spectator_instance_delete(operatorEmail, privilegeSpectatorInstances, reason=reason, showDeletedInstance=showDeletedInstance)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerPrivilegeSpectatorInstanceDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operatorEmail = operatorEmail_example; // String
    let privilegeSpectatorInstances = ; // array[String]
    let reason = reason_example; // String
    let showDeletedInstance = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.organizerPrivilegeSpectatorInstanceDelete(operatorEmail, privilegeSpectatorInstances, reason, showDeletedInstance, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerPrivilegeSpectatorInstancePostRequest organizerPrivilegeSpectatorInstancePostRequest = ; // OrganizerPrivilegeSpectatorInstancePostRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerPrivilegeSpectatorInstancePostRequest organizerPrivilegeSpectatorInstancePostRequest = new OrganizerPrivilegeSpectatorInstancePostRequest(); // OrganizerPrivilegeSpectatorInstancePostRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerPrivilegeSpectatorInstancePostWith:organizerPrivilegeSpectatorInstancePostRequest
              completionHandler: ^(OrganizerPrivilegeSpectatorInstancePostResponse 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 organizerPrivilegeSpectatorInstancePostRequest = ; // {OrganizerPrivilegeSpectatorInstancePostRequest} 

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

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

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

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

            try {
                OrganizerPrivilegeSpectatorInstancePostResponse result = apiInstance.organizerPrivilegeSpectatorInstancePost(organizerPrivilegeSpectatorInstancePostRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeSpectatorInstancePost: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerPrivilegeSpectatorInstancePost($organizerPrivilegeSpectatorInstancePostRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancePost: ', $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 $organizerPrivilegeSpectatorInstancePostRequest = WWW::OPenAPIClient::Object::OrganizerPrivilegeSpectatorInstancePostRequest->new(); # OrganizerPrivilegeSpectatorInstancePostRequest | 

eval {
    my $result = $api_instance->organizerPrivilegeSpectatorInstancePost(organizerPrivilegeSpectatorInstancePostRequest => $organizerPrivilegeSpectatorInstancePostRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancePost: $@\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()
organizerPrivilegeSpectatorInstancePostRequest =  # OrganizerPrivilegeSpectatorInstancePostRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerPrivilegeSpectatorInstancePostRequest = ; // OrganizerPrivilegeSpectatorInstancePostRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerPrivilegeSpectatorInstancePutRequest organizerPrivilegeSpectatorInstancePutRequest = ; // OrganizerPrivilegeSpectatorInstancePutRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerPrivilegeSpectatorInstancePutRequest organizerPrivilegeSpectatorInstancePutRequest = new OrganizerPrivilegeSpectatorInstancePutRequest(); // OrganizerPrivilegeSpectatorInstancePutRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerPrivilegeSpectatorInstancePutWith:organizerPrivilegeSpectatorInstancePutRequest
              completionHandler: ^(OrganizerPrivilegeSpectatorInstancePutResponse 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 organizerPrivilegeSpectatorInstancePutRequest = ; // {OrganizerPrivilegeSpectatorInstancePutRequest} 

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

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

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

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

            try {
                OrganizerPrivilegeSpectatorInstancePutResponse result = apiInstance.organizerPrivilegeSpectatorInstancePut(organizerPrivilegeSpectatorInstancePutRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeSpectatorInstancePut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerPrivilegeSpectatorInstancePut($organizerPrivilegeSpectatorInstancePutRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancePut: ', $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 $organizerPrivilegeSpectatorInstancePutRequest = WWW::OPenAPIClient::Object::OrganizerPrivilegeSpectatorInstancePutRequest->new(); # OrganizerPrivilegeSpectatorInstancePutRequest | 

eval {
    my $result = $api_instance->organizerPrivilegeSpectatorInstancePut(organizerPrivilegeSpectatorInstancePutRequest => $organizerPrivilegeSpectatorInstancePutRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancePut: $@\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()
organizerPrivilegeSpectatorInstancePutRequest =  # OrganizerPrivilegeSpectatorInstancePutRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerPrivilegeSpectatorInstancePutRequest = ; // OrganizerPrivilegeSpectatorInstancePutRequest

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerPrivilegeSpectatorInstancePatchRequest organizerPrivilegeSpectatorInstancePatchRequest = ; // OrganizerPrivilegeSpectatorInstancePatchRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerPrivilegeSpectatorInstancePatchRequest organizerPrivilegeSpectatorInstancePatchRequest = new OrganizerPrivilegeSpectatorInstancePatchRequest(); // OrganizerPrivilegeSpectatorInstancePatchRequest | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerPrivilegeSpectatorInstancesPatchWith:organizerPrivilegeSpectatorInstancePatchRequest
              completionHandler: ^(OrganizerPrivilegeSpectatorInstancePatchResponse 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 organizerPrivilegeSpectatorInstancePatchRequest = ; // {OrganizerPrivilegeSpectatorInstancePatchRequest} 

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

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

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

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

            try {
                OrganizerPrivilegeSpectatorInstancePatchResponse result = apiInstance.organizerPrivilegeSpectatorInstancesPatch(organizerPrivilegeSpectatorInstancePatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPrivilegeSpectatorInstancesPatch: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerPrivilegeSpectatorInstancesPatch($organizerPrivilegeSpectatorInstancePatchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancesPatch: ', $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 $organizerPrivilegeSpectatorInstancePatchRequest = WWW::OPenAPIClient::Object::OrganizerPrivilegeSpectatorInstancePatchRequest->new(); # OrganizerPrivilegeSpectatorInstancePatchRequest | 

eval {
    my $result = $api_instance->organizerPrivilegeSpectatorInstancesPatch(organizerPrivilegeSpectatorInstancePatchRequest => $organizerPrivilegeSpectatorInstancePatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPrivilegeSpectatorInstancesPatch: $@\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()
organizerPrivilegeSpectatorInstancePatchRequest =  # OrganizerPrivilegeSpectatorInstancePatchRequest | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerPrivilegeSpectatorInstancePatchRequest = ; // OrganizerPrivilegeSpectatorInstancePatchRequest

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerProfileGetWithCompletionHandler: 
              ^(OrganizerProfileGetResponse 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.organizerProfileGet(callback);

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerProfile organizerProfile = ; // OrganizerProfile | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerProfile organizerProfile = new OrganizerProfile(); // OrganizerProfile | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

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

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

[apiInstance organizerProfilePutWith:organizerProfile
              completionHandler: ^(OrganizerProfile 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 organizerProfile = ; // {OrganizerProfile} 

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

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

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

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

            try {
                OrganizerProfile result = apiInstance.organizerProfilePut(organizerProfile);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerProfilePut: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerProfilePut($organizerProfile);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerProfilePut: ', $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 $organizerProfile = WWW::OPenAPIClient::Object::OrganizerProfile->new(); # OrganizerProfile | 

eval {
    my $result = $api_instance->organizerProfilePut(organizerProfile => $organizerProfile);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerProfilePut: $@\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()
organizerProfile =  # OrganizerProfile | 

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

extern crate DefaultApi;

pub fn main() {
    let organizerProfile = ; // OrganizerProfile

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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();
        OrganizerReferenceDataKey key = ; // OrganizerReferenceDataKey | Reference data key
        String language = language_example; // String | Language of reference value
        array[String] groups = ; // array[String] | 
        array[String] sites = ; // array[String] | 
        array[String] eventIds = ; // array[String] | List of Event Ids to filter reference value

        try {
            OrganizerReferenceDataResponse result = apiInstance.organizerReferenceDataKeyGet(key, language, groups, sites, eventIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReferenceDataKeyGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrganizerReferenceDataKey key = new OrganizerReferenceDataKey(); // OrganizerReferenceDataKey | Reference data key
final String language = new String(); // String | Language of reference value
final array[String] groups = new array[String](); // array[String] | 
final array[String] sites = new array[String](); // array[String] | 
final array[String] eventIds = new array[String](); // array[String] | List of Event Ids to filter reference value

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerReferenceDataKey key = ; // OrganizerReferenceDataKey | Reference data key
        String language = language_example; // String | Language of reference value
        array[String] groups = ; // array[String] | 
        array[String] sites = ; // array[String] | 
        array[String] eventIds = ; // array[String] | List of Event Ids to filter reference value

        try {
            OrganizerReferenceDataResponse result = apiInstance.organizerReferenceDataKeyGet(key, language, groups, sites, eventIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReferenceDataKeyGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
OrganizerReferenceDataKey *key = ; // Reference data key (default to null)
String *language = language_example; // Language of reference value (optional) (default to null)
array[String] *groups = ; //  (optional) (default to null)
array[String] *sites = ; //  (optional) (default to null)
array[String] *eventIds = ; // List of Event Ids to filter reference value (optional) (default to null)

[apiInstance organizerReferenceDataKeyGetWith:key
    language:language
    groups:groups
    sites:sites
    eventIds:eventIds
              completionHandler: ^(OrganizerReferenceDataResponse 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 key = ; // {OrganizerReferenceDataKey} Reference data key
var opts = {
  'language': language_example, // {String} Language of reference value
  'groups': , // {array[String]} 
  'sites': , // {array[String]} 
  'eventIds':  // {array[String]} List of Event Ids to filter reference value
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var key = new OrganizerReferenceDataKey(); // OrganizerReferenceDataKey | Reference data key (default to null)
            var language = language_example;  // String | Language of reference value (optional)  (default to null)
            var groups = new array[String](); // array[String] |  (optional)  (default to null)
            var sites = new array[String](); // array[String] |  (optional)  (default to null)
            var eventIds = new array[String](); // array[String] | List of Event Ids to filter reference value (optional)  (default to null)

            try {
                OrganizerReferenceDataResponse result = apiInstance.organizerReferenceDataKeyGet(key, language, groups, sites, eventIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerReferenceDataKeyGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$key = ; // OrganizerReferenceDataKey | Reference data key
$language = language_example; // String | Language of reference value
$groups = ; // array[String] | 
$sites = ; // array[String] | 
$eventIds = ; // array[String] | List of Event Ids to filter reference value

try {
    $result = $api_instance->organizerReferenceDataKeyGet($key, $language, $groups, $sites, $eventIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerReferenceDataKeyGet: ', $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 $key = ; # OrganizerReferenceDataKey | Reference data key
my $language = language_example; # String | Language of reference value
my $groups = []; # array[String] | 
my $sites = []; # array[String] | 
my $eventIds = []; # array[String] | List of Event Ids to filter reference value

eval {
    my $result = $api_instance->organizerReferenceDataKeyGet(key => $key, language => $language, groups => $groups, sites => $sites, eventIds => $eventIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerReferenceDataKeyGet: $@\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()
key =  # OrganizerReferenceDataKey | Reference data key (default to null)
language = language_example # String | Language of reference value (optional) (default to null)
groups =  # array[String] |  (optional) (default to null)
sites =  # array[String] |  (optional) (default to null)
eventIds =  # array[String] | List of Event Ids to filter reference value (optional) (default to null)

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

extern crate DefaultApi;

pub fn main() {
    let key = ; // OrganizerReferenceDataKey
    let language = language_example; // String
    let groups = ; // array[String]
    let sites = ; // array[String]
    let eventIds = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerReferenceDataKeyGet(key, language, groups, sites, eventIds, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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] eventIds = ; // array[String] | 
        array[String] contingents = ; // array[String] | 

        try {
            OrganizerEventOverviewReportsAnswer result = apiInstance.organizerReportsEventTicketsGet(eventIds, contingents);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReportsEventTicketsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

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

        try {
            OrganizerEventOverviewReportsAnswer result = apiInstance.organizerReportsEventTicketsGet(eventIds, contingents);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReportsEventTicketsGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerReportsEventTicketsGetWith:eventIds
    contingents:contingents
              completionHandler: ^(OrganizerEventOverviewReportsAnswer 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 eventIds = ; // {array[String]} 
var opts = {
  'contingents':  // {array[String]} 
};

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

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

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

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

            try {
                OrganizerEventOverviewReportsAnswer result = apiInstance.organizerReportsEventTicketsGet(eventIds, contingents);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerReportsEventTicketsGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerReportsEventTicketsGet($eventIds, $contingents);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerReportsEventTicketsGet: ', $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 $eventIds = []; # array[String] | 
my $contingents = []; # array[String] | 

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

try:
    api_response = api_instance.organizer_reports_event_tickets_get(eventIds, contingents=contingents)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerReportsEventTicketsGet: %s\n" % e)

extern crate DefaultApi;

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

    let mut context = DefaultApi::Context::default();
    let result = client.organizerReportsEventTicketsGet(eventIds, contingents, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 reportName = reportName_example; // String | 
        String eventId = eventId_example; // String | 
        Long offset = 789; // Long | 
        Long limit = 789; // Long | 

        try {
            array[OrganizerTicketsPerStatusResponse] result = apiInstance.organizerReportsReportNameEventIdGet(reportName, eventId, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReportsReportNameEventIdGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String reportName = new String(); // String | 
final String eventId = new String(); // String | 
final Long offset = new Long(); // Long | 
final Long limit = new Long(); // Long | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String reportName = reportName_example; // String | 
        String eventId = eventId_example; // String | 
        Long offset = 789; // Long | 
        Long limit = 789; // Long | 

        try {
            array[OrganizerTicketsPerStatusResponse] result = apiInstance.organizerReportsReportNameEventIdGet(reportName, eventId, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerReportsReportNameEventIdGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerReportsReportNameEventIdGetWith:reportName
    eventId:eventId
    offset:offset
    limit:limit
              completionHandler: ^(array[OrganizerTicketsPerStatusResponse] 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 reportName = reportName_example; // {String} 
var eventId = eventId_example; // {String} 
var offset = 789; // {Long} 
var limit = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var reportName = reportName_example;  // String |  (default to null)
            var eventId = eventId_example;  // String |  (default to null)
            var offset = 789;  // Long |  (default to null)
            var limit = 789;  // Long |  (default to null)

            try {
                array[OrganizerTicketsPerStatusResponse] result = apiInstance.organizerReportsReportNameEventIdGet(reportName, eventId, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerReportsReportNameEventIdGet: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->organizerReportsReportNameEventIdGet($reportName, $eventId, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerReportsReportNameEventIdGet: ', $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 $reportName = reportName_example; # String | 
my $eventId = eventId_example; # String | 
my $offset = 789; # Long | 
my $limit = 789; # Long | 

eval {
    my $result = $api_instance->organizerReportsReportNameEventIdGet(reportName => $reportName, eventId => $eventId, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerReportsReportNameEventIdGet: $@\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()
reportName = reportName_example # String |  (default to null)
eventId = eventId_example # String |  (default to null)
offset = 789 # Long |  (default to null)
limit = 789 # Long |  (default to null)

try:
    api_response = api_instance.organizer_reports_report_name_event_id_get(reportName, eventId, offset, limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerReportsReportNameEventIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let reportName = reportName_example; // String
    let eventId = eventId_example; // String
    let offset = 789; // Long
    let limit = 789; // Long

    let mut context = DefaultApi::Context::default();
    let result = client.organizerReportsReportNameEventIdGet(reportName, eventId, offset, limit, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSecuritytokensMobileAppIdSpectatorEmailDelete");
            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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSecuritytokensMobileAppIdSpectatorEmailDelete: $e\n');
}

import com.secutix.tixngo.v1.0.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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSecuritytokensMobileAppIdSpectatorEmailDelete");
            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 organizerSecuritytokensMobileAppIdSpectatorEmailDeleteWith: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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail, callback);

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

namespace Example
{
    public class organizerSecuritytokensMobileAppIdSpectatorEmailDeleteExample
    {
        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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSecuritytokensMobileAppIdSpectatorEmailDelete: " + 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->organizerSecuritytokensMobileAppIdSpectatorEmailDelete($mobileAppId, $spectatorEmail);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSecuritytokensMobileAppIdSpectatorEmailDelete: ', $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->organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId => $mobileAppId, spectatorEmail => $spectatorEmail);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSecuritytokensMobileAppIdSpectatorEmailDelete: $@\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_securitytokens_mobile_app_id_spectator_email_delete(mobileAppId, spectatorEmail)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSecuritytokensMobileAppIdSpectatorEmailDelete: %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.organizerSecuritytokensMobileAppIdSpectatorEmailDelete(mobileAppId, spectatorEmail, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String key = key_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String key = key_example; // String | 

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

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

[apiInstance organizerSettingsGetWith:limit
    offset:offset
    key:key
              completionHandler: ^(OrganizerSettingsResponse 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 = 56; // {Integer} 
var offset = 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.organizerSettingsGet(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 organizerSettingsGetExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (default to null)
            var offset = 56;  // Integer |  (default to null)
            var key = key_example;  // String |  (optional)  (default to null)

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

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

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

try {
    $result = $api_instance->organizerSettingsGet($limit, $offset, $key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSettingsGet: ', $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 = 56; # Integer | 
my $offset = 56; # Integer | 
my $key = key_example; # String | 

eval {
    my $result = $api_instance->organizerSettingsGet(limit => $limit, offset => $offset, key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSettingsGet: $@\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 = 56 # Integer |  (default to null)
offset = 56 # Integer |  (default to null)
key = key_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_settings_get(limit, offset, key=key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSettingsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let key = key_example; // String

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

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 key = key_example; // String | 
        OrganizerEditableSetting organizerEditableSetting = ; // OrganizerEditableSetting | 

        try {
            OrganizerSetting result = apiInstance.organizerSettingsKeyPatch(key, organizerEditableSetting);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String key = new String(); // String | 
final OrganizerEditableSetting organizerEditableSetting = new OrganizerEditableSetting(); // OrganizerEditableSetting | 

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String key = key_example; // String | 
        OrganizerEditableSetting organizerEditableSetting = ; // OrganizerEditableSetting | 

        try {
            OrganizerSetting result = apiInstance.organizerSettingsKeyPatch(key, organizerEditableSetting);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerSettingsKeyPatchWith:key
    organizerEditableSetting:organizerEditableSetting
              completionHandler: ^(OrganizerSetting 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 key = key_example; // {String} 
var opts = {
  'organizerEditableSetting':  // {OrganizerEditableSetting} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var key = key_example;  // String |  (default to null)
            var organizerEditableSetting = new OrganizerEditableSetting(); // OrganizerEditableSetting |  (optional) 

            try {
                OrganizerSetting result = apiInstance.organizerSettingsKeyPatch(key, organizerEditableSetting);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSettingsKeyPatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$key = key_example; // String | 
$organizerEditableSetting = ; // OrganizerEditableSetting | 

try {
    $result = $api_instance->organizerSettingsKeyPatch($key, $organizerEditableSetting);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSettingsKeyPatch: ', $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 $key = key_example; # String | 
my $organizerEditableSetting = WWW::OPenAPIClient::Object::OrganizerEditableSetting->new(); # OrganizerEditableSetting | 

eval {
    my $result = $api_instance->organizerSettingsKeyPatch(key => $key, organizerEditableSetting => $organizerEditableSetting);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSettingsKeyPatch: $@\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()
key = key_example # String |  (default to null)
organizerEditableSetting =  # OrganizerEditableSetting |  (optional)

try:
    api_response = api_instance.organizer_settings_key_patch(key, organizerEditableSetting=organizerEditableSetting)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSettingsKeyPatch: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let key = key_example; // String
    let organizerEditableSetting = ; // OrganizerEditableSetting

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSettingsKeyPatch(key, organizerEditableSetting, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 firstName = firstName_example; // String | 
        String lastName = lastName_example; // String | 
        String fileId = fileId_example; // String | 
        String appVersion = appVersion_example; // String | 

        try {
            OrganizerSpectatorsSearchResponse result = apiInstance.organizerSpectatorsGet(limit, offset, email, mobileAppId, phoneNumber, firstName, lastName, fileId, appVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsGet");
            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 firstName = new String(); // String | 
final String lastName = new String(); // String | 
final String fileId = new String(); // String | 
final String appVersion = new String(); // String | 

try {
    final result = await api_instance.organizerSpectatorsGet(limit, offset, email, mobileAppId, phoneNumber, firstName, lastName, fileId, appVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSpectatorsGet: $e\n');
}

import com.secutix.tixngo.v1.0.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 firstName = firstName_example; // String | 
        String lastName = lastName_example; // String | 
        String fileId = fileId_example; // String | 
        String appVersion = appVersion_example; // String | 

        try {
            OrganizerSpectatorsSearchResponse result = apiInstance.organizerSpectatorsGet(limit, offset, email, mobileAppId, phoneNumber, firstName, lastName, fileId, appVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsGet");
            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 *firstName = firstName_example; //  (optional) (default to null)
String *lastName = lastName_example; //  (optional) (default to null)
String *fileId = fileId_example; //  (optional) (default to null)
String *appVersion = appVersion_example; //  (optional) (default to null)

[apiInstance organizerSpectatorsGetWith:limit
    offset:offset
    email:email
    mobileAppId:mobileAppId
    phoneNumber:phoneNumber
    firstName:firstName
    lastName:lastName
    fileId:fileId
    appVersion:appVersion
              completionHandler: ^(OrganizerSpectatorsSearchResponse 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} 
  'firstName': firstName_example, // {String} 
  'lastName': lastName_example, // {String} 
  'fileId': fileId_example, // {String} 
  'appVersion': appVersion_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.organizerSpectatorsGet(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 organizerSpectatorsGetExample
    {
        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 firstName = firstName_example;  // String |  (optional)  (default to null)
            var lastName = lastName_example;  // String |  (optional)  (default to null)
            var fileId = fileId_example;  // String |  (optional)  (default to null)
            var appVersion = appVersion_example;  // String |  (optional)  (default to null)

            try {
                OrganizerSpectatorsSearchResponse result = apiInstance.organizerSpectatorsGet(limit, offset, email, mobileAppId, phoneNumber, firstName, lastName, fileId, appVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSpectatorsGet: " + 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 | 
$firstName = firstName_example; // String | 
$lastName = lastName_example; // String | 
$fileId = fileId_example; // String | 
$appVersion = appVersion_example; // String | 

try {
    $result = $api_instance->organizerSpectatorsGet($limit, $offset, $email, $mobileAppId, $phoneNumber, $firstName, $lastName, $fileId, $appVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSpectatorsGet: ', $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 $firstName = firstName_example; # String | 
my $lastName = lastName_example; # String | 
my $fileId = fileId_example; # String | 
my $appVersion = appVersion_example; # String | 

eval {
    my $result = $api_instance->organizerSpectatorsGet(limit => $limit, offset => $offset, email => $email, mobileAppId => $mobileAppId, phoneNumber => $phoneNumber, firstName => $firstName, lastName => $lastName, fileId => $fileId, appVersion => $appVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSpectatorsGet: $@\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)
firstName = firstName_example # String |  (optional) (default to null)
lastName = lastName_example # String |  (optional) (default to null)
fileId = fileId_example # String |  (optional) (default to null)
appVersion = appVersion_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_spectators_get(limit, offset, email=email, mobileAppId=mobileAppId, phoneNumber=phoneNumber, firstName=firstName, lastName=lastName, fileId=fileId, appVersion=appVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSpectatorsGet: %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 firstName = firstName_example; // String
    let lastName = lastName_example; // String
    let fileId = fileId_example; // String
    let appVersion = appVersion_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSpectatorsGet(limit, offset, email, mobileAppId, phoneNumber, firstName, lastName, fileId, appVersion, &context).wait();

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

import com.secutix.tixngo.v1.0.*;
import com.secutix.tixngo.v1.0.auth.*;
import com.secutix.tixngo.v1.0.model.*;
import com.secutix.tixngo.v1.0.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 spectatorId = spectatorId_example; // String | the email of the spectator
        String mobileAppId = mobileAppId_example; // String | Mobile app id of spectator
        Boolean mustNotifySpectator = true; // Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String spectatorId = new String(); // String | the email of the spectator
final String mobileAppId = new String(); // String | Mobile app id of spectator
final Boolean mustNotifySpectator = new Boolean(); // Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation

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

import com.secutix.tixngo.v1.0.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String spectatorId = spectatorId_example; // String | the email of the spectator
        String mobileAppId = mobileAppId_example; // String | Mobile app id of spectator
        Boolean mustNotifySpectator = true; // Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *spectatorId = spectatorId_example; // the email of the spectator (default to null)
String *mobileAppId = mobileAppId_example; // Mobile app id of spectator (default to null)
Boolean *mustNotifySpectator = true; // false to anonymize immediately - true to apply communicating spectator through email for confirmation (default to null)

[apiInstance organizerSpectatorsSpectatorIdDeleteWith:spectatorId
    mobileAppId:mobileAppId
    mustNotifySpectator:mustNotifySpectator
              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 spectatorId = spectatorId_example; // {String} the email of the spectator
var mobileAppId = mobileAppId_example; // {String} Mobile app id of spectator
var mustNotifySpectator = true; // {Boolean} false to anonymize immediately - true to apply communicating spectator through email for confirmation

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var spectatorId = spectatorId_example;  // String | the email of the spectator (default to null)
            var mobileAppId = mobileAppId_example;  // String | Mobile app id of spectator (default to null)
            var mustNotifySpectator = true;  // Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$spectatorId = spectatorId_example; // String | the email of the spectator
$mobileAppId = mobileAppId_example; // String | Mobile app id of spectator
$mustNotifySpectator = true; // Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation

try {
    $api_instance->organizerSpectatorsSpectatorIdDelete($spectatorId, $mobileAppId, $mustNotifySpectator);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSpectatorsSpectatorIdDelete: ', $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 $spectatorId = spectatorId_example; # String | the email of the spectator
my $mobileAppId = mobileAppId_example; # String | Mobile app id of spectator
my $mustNotifySpectator = true; # Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation

eval {
    $api_instance->organizerSpectatorsSpectatorIdDelete(spectatorId => $spectatorId, mobileAppId => $mobileAppId, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSpectatorsSpectatorIdDelete: $@\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()
spectatorId = spectatorId_example # String | the email of the spectator (default to null)
mobileAppId = mobileAppId_example # String | Mobile app id of spectator (default to null)
mustNotifySpectator = true # Boolean | false to anonymize immediately - true to apply communicating spectator through email for confirmation (default to null)

try:
    api_instance.organizer_spectators_spectator_id_delete(spectatorId, mobileAppId, mustNotifySpectator)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSpectatorsSpectatorIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let spectatorId = spectatorId_example; // String
    let mobileAppId = mobileAppId_example; // String
    let mustNotifySpectator = true; // Boolean

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

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