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

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

        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 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();
        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();
        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) {
        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();
        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();
        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();
        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();
        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 spectatorId = spectatorId_example; // String | the email of the spectator
        String mobileAppId = mobileAppId_example; // String | Mobile app id of spectator

        try {
            OrgSpecLockInfo result = apiInstance.organizerSpectatorsSpectatorIdLockGet(spectatorId, mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsSpectatorIdLockGet");
            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

try {
    final result = await api_instance.organizerSpectatorsSpectatorIdLockGet(spectatorId, mobileAppId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockGet: $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

        try {
            OrgSpecLockInfo result = apiInstance.organizerSpectatorsSpectatorIdLockGet(spectatorId, mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsSpectatorIdLockGet");
            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)

[apiInstance organizerSpectatorsSpectatorIdLockGetWith:spectatorId
    mobileAppId:mobileAppId
              completionHandler: ^(OrgSpecLockInfo 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 spectatorId = spectatorId_example; // {String} the email of the spectator
var mobileAppId = mobileAppId_example; // {String} Mobile app id of spectator

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

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

namespace Example
{
    public class organizerSpectatorsSpectatorIdLockGetExample
    {
        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)

            try {
                OrgSpecLockInfo result = apiInstance.organizerSpectatorsSpectatorIdLockGet(spectatorId, mobileAppId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSpectatorsSpectatorIdLockGet: " + 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

try {
    $result = $api_instance->organizerSpectatorsSpectatorIdLockGet($spectatorId, $mobileAppId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockGet: ', $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

eval {
    my $result = $api_instance->organizerSpectatorsSpectatorIdLockGet(spectatorId => $spectatorId, mobileAppId => $mobileAppId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockGet: $@\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)

try:
    api_response = api_instance.organizer_spectators_spectator_id_lock_get(spectatorId, mobileAppId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockGet: %s\n" % e)

extern crate DefaultApi;

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

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSpectatorsSpectatorIdLockGet(spectatorId, 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 spectatorId = spectatorId_example; // String | the email of the spectator
        String mobileAppId = mobileAppId_example; // String | Mobile app id of spectator
        OrgSpecLockInfo orgSpecLockInfo = ; // OrgSpecLockInfo | 
        Boolean mustNotifySpectator = true; // Boolean | 

        try {
            apiInstance.organizerSpectatorsSpectatorIdLockPatch(spectatorId, mobileAppId, orgSpecLockInfo, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsSpectatorIdLockPatch");
            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 OrgSpecLockInfo orgSpecLockInfo = new OrgSpecLockInfo(); // OrgSpecLockInfo | 
final Boolean mustNotifySpectator = new Boolean(); // Boolean | 

try {
    final result = await api_instance.organizerSpectatorsSpectatorIdLockPatch(spectatorId, mobileAppId, orgSpecLockInfo, mustNotifySpectator);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockPatch: $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
        OrgSpecLockInfo orgSpecLockInfo = ; // OrgSpecLockInfo | 
        Boolean mustNotifySpectator = true; // Boolean | 

        try {
            apiInstance.organizerSpectatorsSpectatorIdLockPatch(spectatorId, mobileAppId, orgSpecLockInfo, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSpectatorsSpectatorIdLockPatch");
            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)
OrgSpecLockInfo *orgSpecLockInfo = ; // 
Boolean *mustNotifySpectator = true; //  (optional) (default to null)

[apiInstance organizerSpectatorsSpectatorIdLockPatchWith:spectatorId
    mobileAppId:mobileAppId
    orgSpecLockInfo:orgSpecLockInfo
    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 orgSpecLockInfo = ; // {OrgSpecLockInfo} 
var opts = {
  'mustNotifySpectator': true // {Boolean} 
};

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

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

namespace Example
{
    public class organizerSpectatorsSpectatorIdLockPatchExample
    {
        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 orgSpecLockInfo = new OrgSpecLockInfo(); // OrgSpecLockInfo | 
            var mustNotifySpectator = true;  // Boolean |  (optional)  (default to null)

            try {
                apiInstance.organizerSpectatorsSpectatorIdLockPatch(spectatorId, mobileAppId, orgSpecLockInfo, mustNotifySpectator);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSpectatorsSpectatorIdLockPatch: " + 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
$orgSpecLockInfo = ; // OrgSpecLockInfo | 
$mustNotifySpectator = true; // Boolean | 

try {
    $api_instance->organizerSpectatorsSpectatorIdLockPatch($spectatorId, $mobileAppId, $orgSpecLockInfo, $mustNotifySpectator);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockPatch: ', $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 $orgSpecLockInfo = WWW::OPenAPIClient::Object::OrgSpecLockInfo->new(); # OrgSpecLockInfo | 
my $mustNotifySpectator = true; # Boolean | 

eval {
    $api_instance->organizerSpectatorsSpectatorIdLockPatch(spectatorId => $spectatorId, mobileAppId => $mobileAppId, orgSpecLockInfo => $orgSpecLockInfo, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSpectatorsSpectatorIdLockPatch: $@\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)
orgSpecLockInfo =  # OrgSpecLockInfo | 
mustNotifySpectator = true # Boolean |  (optional) (default to null)

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

extern crate DefaultApi;

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

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSpectatorsSpectatorIdLockPatch(spectatorId, mobileAppId, orgSpecLockInfo, mustNotifySpectator, &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 | 
        String mobileAppId = mobileAppId_example; // String | 
        String firstName = firstName_example; // String | 
        String lastName = lastName_example; // String | 
        String idCardNumber = idCardNumber_example; // String | 
        String passportNumber = passportNumber_example; // String | 
        String ticketId = ticketId_example; // String | 
        String barcode = barcode_example; // String | 

        try {
            OrganizerSupportSpectator result = apiInstance.organizerSupportSpectatorGet(email, mobileAppId, firstName, lastName, idCardNumber, passportNumber, ticketId, barcode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSupportSpectatorGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String email = new String(); // String | 
final String mobileAppId = new String(); // String | 
final String firstName = new String(); // String | 
final String lastName = new String(); // String | 
final String idCardNumber = new String(); // String | 
final String passportNumber = new String(); // String | 
final String ticketId = new String(); // String | 
final String barcode = new String(); // String | 

try {
    final result = await api_instance.organizerSupportSpectatorGet(email, mobileAppId, firstName, lastName, idCardNumber, passportNumber, ticketId, barcode);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSupportSpectatorGet: $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 | 
        String mobileAppId = mobileAppId_example; // String | 
        String firstName = firstName_example; // String | 
        String lastName = lastName_example; // String | 
        String idCardNumber = idCardNumber_example; // String | 
        String passportNumber = passportNumber_example; // String | 
        String ticketId = ticketId_example; // String | 
        String barcode = barcode_example; // String | 

        try {
            OrganizerSupportSpectator result = apiInstance.organizerSupportSpectatorGet(email, mobileAppId, firstName, lastName, idCardNumber, passportNumber, ticketId, barcode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSupportSpectatorGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *email = email_example; //  (optional) (default to null)
String *mobileAppId = mobileAppId_example; //  (optional) (default to null)
String *firstName = firstName_example; //  (optional) (default to null)
String *lastName = lastName_example; //  (optional) (default to null)
String *idCardNumber = idCardNumber_example; //  (optional) (default to null)
String *passportNumber = passportNumber_example; //  (optional) (default to null)
String *ticketId = ticketId_example; //  (optional) (default to null)
String *barcode = barcode_example; //  (optional) (default to null)

[apiInstance organizerSupportSpectatorGetWith:email
    mobileAppId:mobileAppId
    firstName:firstName
    lastName:lastName
    idCardNumber:idCardNumber
    passportNumber:passportNumber
    ticketId:ticketId
    barcode:barcode
              completionHandler: ^(OrganizerSupportSpectator 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 = {
  'email': email_example, // {String} 
  'mobileAppId': mobileAppId_example, // {String} 
  'firstName': firstName_example, // {String} 
  'lastName': lastName_example, // {String} 
  'idCardNumber': idCardNumber_example, // {String} 
  'passportNumber': passportNumber_example, // {String} 
  'ticketId': ticketId_example, // {String} 
  'barcode': barcode_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var email = email_example;  // String |  (optional)  (default to null)
            var mobileAppId = mobileAppId_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 idCardNumber = idCardNumber_example;  // String |  (optional)  (default to null)
            var passportNumber = passportNumber_example;  // String |  (optional)  (default to null)
            var ticketId = ticketId_example;  // String |  (optional)  (default to null)
            var barcode = barcode_example;  // String |  (optional)  (default to null)

            try {
                OrganizerSupportSpectator result = apiInstance.organizerSupportSpectatorGet(email, mobileAppId, firstName, lastName, idCardNumber, passportNumber, ticketId, barcode);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerSupportSpectatorGet: " + 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 | 
$mobileAppId = mobileAppId_example; // String | 
$firstName = firstName_example; // String | 
$lastName = lastName_example; // String | 
$idCardNumber = idCardNumber_example; // String | 
$passportNumber = passportNumber_example; // String | 
$ticketId = ticketId_example; // String | 
$barcode = barcode_example; // String | 

try {
    $result = $api_instance->organizerSupportSpectatorGet($email, $mobileAppId, $firstName, $lastName, $idCardNumber, $passportNumber, $ticketId, $barcode);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerSupportSpectatorGet: ', $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 | 
my $mobileAppId = mobileAppId_example; # String | 
my $firstName = firstName_example; # String | 
my $lastName = lastName_example; # String | 
my $idCardNumber = idCardNumber_example; # String | 
my $passportNumber = passportNumber_example; # String | 
my $ticketId = ticketId_example; # String | 
my $barcode = barcode_example; # String | 

eval {
    my $result = $api_instance->organizerSupportSpectatorGet(email => $email, mobileAppId => $mobileAppId, firstName => $firstName, lastName => $lastName, idCardNumber => $idCardNumber, passportNumber => $passportNumber, ticketId => $ticketId, barcode => $barcode);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerSupportSpectatorGet: $@\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 |  (optional) (default to null)
mobileAppId = mobileAppId_example # String |  (optional) (default to null)
firstName = firstName_example # String |  (optional) (default to null)
lastName = lastName_example # String |  (optional) (default to null)
idCardNumber = idCardNumber_example # String |  (optional) (default to null)
passportNumber = passportNumber_example # String |  (optional) (default to null)
ticketId = ticketId_example # String |  (optional) (default to null)
barcode = barcode_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_support_spectator_get(email=email, mobileAppId=mobileAppId, firstName=firstName, lastName=lastName, idCardNumber=idCardNumber, passportNumber=passportNumber, ticketId=ticketId, barcode=barcode)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerSupportSpectatorGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let email = email_example; // String
    let mobileAppId = mobileAppId_example; // String
    let firstName = firstName_example; // String
    let lastName = lastName_example; // String
    let idCardNumber = idCardNumber_example; // String
    let passportNumber = passportNumber_example; // String
    let ticketId = ticketId_example; // String
    let barcode = barcode_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSupportSpectatorGet(email, mobileAppId, firstName, lastName, idCardNumber, passportNumber, ticketId, barcode, &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[ApplicationInfo] result = apiInstance.organizerSupportedApplicationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSupportedApplicationsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.organizerSupportedApplicationsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerSupportedApplicationsGet: $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[ApplicationInfo] result = apiInstance.organizerSupportedApplicationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerSupportedApplicationsGet");
            e.printStackTrace();
        }
    }
}

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

[apiInstance organizerSupportedApplicationsGetWithCompletionHandler: 
              ^(array[ApplicationInfo] 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.organizerSupportedApplicationsGet(callback);

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

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

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

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

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.organizerSupportedApplicationsGet(&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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.organizerTicketDetailsKeysGet(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerTicketDetailsKeysGet: $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 | 

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

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

[apiInstance organizerTicketDetailsKeysGetWith:eventId
              completionHandler: ^(OrganizerTicketDetailsKeysResponse 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 = {
  'eventId': eventId_example // {String} 
};

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

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

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

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

            try {
                OrganizerTicketDetailsKeysResponse result = apiInstance.organizerTicketDetailsKeysGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerTicketDetailsKeysGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DefaultApi;

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

    let mut context = DefaultApi::Context::default();
    let result = client.organizerTicketDetailsKeysGet(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 mobileAppId = mobileAppId_example; // String | 
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        String lang = lang_example; // String | 
        String key = key_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.organizerTranslationsGet(mobileAppId, offset, limit, lang, key);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerTranslationsGet: $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 | 
        Integer offset = 56; // Integer | 
        Integer limit = 56; // Integer | 
        String lang = lang_example; // String | 
        String key = key_example; // String | 

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

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

[apiInstance organizerTranslationsGetWith:mobileAppId
    offset:offset
    limit:limit
    lang:lang
    key:key
              completionHandler: ^(Multilingual 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 offset = 56; // {Integer} 
var limit = 56; // {Integer} 
var opts = {
  'lang': lang_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.organizerTranslationsGet(mobileAppId, 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 organizerTranslationsGetExample
    {
        public void main()
        {

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

            try {
                Multilingual result = apiInstance.organizerTranslationsGet(mobileAppId, offset, limit, lang, key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerTranslationsGet: " + 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 | 
$offset = 56; // Integer | 
$limit = 56; // Integer | 
$lang = lang_example; // String | 
$key = key_example; // String | 

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

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

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

extern crate DefaultApi;

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

    let mut context = DefaultApi::Context::default();
    let result = client.organizerTranslationsGet(mobileAppId, offset, limit, lang, 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 | 
        String lang = lang_example; // String | 
        String key = key_example; // String | 
        String body = body_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String mobileAppId = new String(); // String | 
final String lang = new String(); // String | 
final String key = new String(); // String | 
final String body = new String(); // String | 

try {
    final result = await api_instance.organizerTranslationsMobileAppIdLangKeyPut(mobileAppId, lang, key, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerTranslationsMobileAppIdLangKeyPut: $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 lang = lang_example; // String | 
        String key = key_example; // String | 
        String body = body_example; // String | 

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

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

[apiInstance organizerTranslationsMobileAppIdLangKeyPutWith:mobileAppId
    lang:lang
    key:key
    body:body
              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 lang = lang_example; // {String} 
var key = key_example; // {String} 
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var lang = lang_example;  // String |  (default to null)
            var key = key_example;  // String |  (default to null)
            var body = body_example;  // String | 

            try {
                apiInstance.organizerTranslationsMobileAppIdLangKeyPut(mobileAppId, lang, key, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerTranslationsMobileAppIdLangKeyPut: " + 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 | 
$lang = lang_example; // String | 
$key = key_example; // String | 
$body = body_example; // String | 

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

eval {
    $api_instance->organizerTranslationsMobileAppIdLangKeyPut(mobileAppId => $mobileAppId, lang => $lang, key => $key, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerTranslationsMobileAppIdLangKeyPut: $@\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)
lang = lang_example # String |  (default to null)
key = key_example # String |  (default to null)
body = body_example # String | 

try:
    api_instance.organizer_translations_mobile_app_id_lang_key_put(mobileAppId, lang, key, body)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerTranslationsMobileAppIdLangKeyPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String
    let lang = lang_example; // String
    let key = key_example; // String
    let body = body_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerTranslationsMobileAppIdLangKeyPut(mobileAppId, lang, key, body, &context).wait();

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