import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean excludeTransferRules = true; // Boolean | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String offset = new String(); // String | 
final String limit = new String(); // String | 
final String eventName = new String(); // String | 
final String eventId = new String(); // String | 
final array[String] eventIds = new array[String](); // array[String] | 
final date startDate = new date(); // date | 
final EventFilter filter = new EventFilter(); // EventFilter | 
final Date dateFrom = new Date(); // Date | 
final Date dateTo = new Date(); // Date | 
final Boolean excludeTransferRules = new Boolean(); // Boolean | 
final array[String] eventGroupIds = new array[String](); // array[String] | 

try {
    final result = await api_instance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->organizerEventsGet: $e\n');
}

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

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] eventIds = ; // array[String] | 
        date startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
        EventFilter filter = ; // EventFilter | 
        Date dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date dateTo = 2013-10-20T19:20:30+01:00; // Date | 
        Boolean excludeTransferRules = true; // Boolean | 
        array[String] eventGroupIds = ; // array[String] | 

        try {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *offset = offset_example; //  (default to null)
String *limit = limit_example; //  (default to null)
String *eventName = eventName_example; //  (optional) (default to null)
String *eventId = eventId_example; //  (optional) (default to null)
array[String] *eventIds = ; //  (optional) (default to null)
date *startDate = Thu Feb 20 00:00:00 UTC 2020; //  (optional) (default to null)
EventFilter *filter = ; //  (optional) (default to null)
Date *dateFrom = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *dateTo = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Boolean *excludeTransferRules = true; //  (optional) (default to null)
array[String] *eventGroupIds = ; //  (optional) (default to null)

[apiInstance organizerEventsGetWith:offset
    limit:limit
    eventName:eventName
    eventId:eventId
    eventIds:eventIds
    startDate:startDate
    filter:filter
    dateFrom:dateFrom
    dateTo:dateTo
    excludeTransferRules:excludeTransferRules
    eventGroupIds:eventGroupIds
              completionHandler: ^(OrganizerEventsGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

// Create an instance of the API class
var api = new TixngoRestApiBackendOrganizerApi.DefaultApi()
var offset = offset_example; // {String} 
var limit = limit_example; // {String} 
var opts = {
  'eventName': eventName_example, // {String} 
  'eventId': eventId_example, // {String} 
  'eventIds': , // {array[String]} 
  'startDate': Thu Feb 20 00:00:00 UTC 2020, // {date} 
  'filter': , // {EventFilter} 
  'dateFrom': 2013-10-20T19:20:30+01:00, // {Date} 
  'dateTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'excludeTransferRules': true, // {Boolean} 
  'eventGroupIds':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = offset_example;  // String |  (default to null)
            var limit = limit_example;  // String |  (default to null)
            var eventName = eventName_example;  // String |  (optional)  (default to null)
            var eventId = eventId_example;  // String |  (optional)  (default to null)
            var eventIds = new array[String](); // array[String] |  (optional)  (default to null)
            var startDate = Thu Feb 20 00:00:00 UTC 2020;  // date |  (optional)  (default to null)
            var filter = new EventFilter(); // EventFilter |  (optional)  (default to null)
            var dateFrom = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var dateTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var excludeTransferRules = true;  // Boolean |  (optional)  (default to null)
            var eventGroupIds = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = offset_example; // String | 
$limit = limit_example; // String | 
$eventName = eventName_example; // String | 
$eventId = eventId_example; // String | 
$eventIds = ; // array[String] | 
$startDate = Thu Feb 20 00:00:00 UTC 2020; // date | 
$filter = ; // EventFilter | 
$dateFrom = 2013-10-20T19:20:30+01:00; // Date | 
$dateTo = 2013-10-20T19:20:30+01:00; // Date | 
$excludeTransferRules = true; // Boolean | 
$eventGroupIds = ; // array[String] | 

try {
    $result = $api_instance->organizerEventsGet($offset, $limit, $eventName, $eventId, $eventIds, $startDate, $filter, $dateFrom, $dateTo, $excludeTransferRules, $eventGroupIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $offset = offset_example; # String | 
my $limit = limit_example; # String | 
my $eventName = eventName_example; # String | 
my $eventId = eventId_example; # String | 
my $eventIds = []; # array[String] | 
my $startDate = Thu Feb 20 00:00:00 UTC 2020; # date | 
my $filter = ; # EventFilter | 
my $dateFrom = 2013-10-20T19:20:30+01:00; # Date | 
my $dateTo = 2013-10-20T19:20:30+01:00; # Date | 
my $excludeTransferRules = true; # Boolean | 
my $eventGroupIds = []; # array[String] | 

eval {
    my $result = $api_instance->organizerEventsGet(offset => $offset, limit => $limit, eventName => $eventName, eventId => $eventId, eventIds => $eventIds, startDate => $startDate, filter => $filter, dateFrom => $dateFrom, dateTo => $dateTo, excludeTransferRules => $excludeTransferRules, eventGroupIds => $eventGroupIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
offset = offset_example # String |  (default to null)
limit = limit_example # String |  (default to null)
eventName = eventName_example # String |  (optional) (default to null)
eventId = eventId_example # String |  (optional) (default to null)
eventIds =  # array[String] |  (optional) (default to null)
startDate = Thu Feb 20 00:00:00 UTC 2020 # date |  (optional) (default to null)
filter =  # EventFilter |  (optional) (default to null)
dateFrom = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
dateTo = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
excludeTransferRules = true # Boolean |  (optional) (default to null)
eventGroupIds =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.organizer_events_get(offset, limit, eventName=eventName, eventId=eventId, eventIds=eventIds, startDate=startDate, filter=filter, dateFrom=dateFrom, dateTo=dateTo, excludeTransferRules=excludeTransferRules, eventGroupIds=eventGroupIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let offset = offset_example; // String
    let limit = limit_example; // String
    let eventName = eventName_example; // String
    let eventId = eventId_example; // String
    let eventIds = ; // array[String]
    let startDate = Thu Feb 20 00:00:00 UTC 2020; // date
    let filter = ; // EventFilter
    let dateFrom = 2013-10-20T19:20:30+01:00; // Date
    let dateTo = 2013-10-20T19:20:30+01:00; // Date
    let excludeTransferRules = true; // Boolean
    let eventGroupIds = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsGet(offset, limit, eventName, eventId, eventIds, startDate, filter, dateFrom, dateTo, excludeTransferRules, eventGroupIds, &context).wait();

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.DefaultApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

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

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

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

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

[apiInstance organizerEventsPutWith:orgEventsPutRequest
              completionHandler: ^(OrgEventResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var TixngoRestApiBackendOrganizerApi = require('tixngo_rest_api_backend_organizer_api');

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

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->organizerEventsPut(orgEventsPutRequest => $orgEventsPutRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

extern crate DefaultApi;

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

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

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.EventsApi;

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

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

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

        try {
            OrgEventResponse result = apiInstance.organizerEventsPost(orgEventsPostRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsApi#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.v4.0.api.EventsApi;

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

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

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

// Event creation
[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.EventsApi()
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 EventsApi();
            var orgEventsPostRequest = new OrgEventsPostRequest(); // OrgEventsPostRequest | 

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

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

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventsApi->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 EventsApi->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.EventsApi()
orgEventsPostRequest =  # OrgEventsPostRequest | 

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

extern crate EventsApi;

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

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

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.TicketsApi;

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

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

        // Create an instance of the API class
        TicketsApi apiInstance = new TicketsApi();
        array[OrganizerTicketControlOrder] organizerTicketControlOrder = ; // array[OrganizerTicketControlOrder] | 

        try {
            array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsControlEventsPost(organizerTicketControlOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsControlEventsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[OrganizerTicketControlOrder] organizerTicketControlOrder = new array[OrganizerTicketControlOrder](); // array[OrganizerTicketControlOrder] | 

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

import com.secutix.tixngo.v4.0.api.TicketsApi;

public class TicketsApiExample {
    public static void main(String[] args) {
        TicketsApi apiInstance = new TicketsApi();
        array[OrganizerTicketControlOrder] organizerTicketControlOrder = ; // array[OrganizerTicketControlOrder] | 

        try {
            array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsControlEventsPost(organizerTicketControlOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsControlEventsPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TicketsApi *apiInstance = [[TicketsApi alloc] init];
array[OrganizerTicketControlOrder] *organizerTicketControlOrder = ; // 

// Ticket update
[apiInstance organizerTicketsControlEventsPostWith:organizerTicketControlOrder
              completionHandler: ^(array[OrganizerTicketInterfaceResponseEntry] 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.TicketsApi()
var organizerTicketControlOrder = ; // {array[OrganizerTicketControlOrder]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketsApi();
            var organizerTicketControlOrder = new array[OrganizerTicketControlOrder](); // array[OrganizerTicketControlOrder] | 

            try {
                // Ticket update
                array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsControlEventsPost(organizerTicketControlOrder);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketsApi.organizerTicketsControlEventsPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketsApi();
$organizerTicketControlOrder = ; // array[OrganizerTicketControlOrder] | 

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

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

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

eval {
    my $result = $api_instance->organizerTicketsControlEventsPost(organizerTicketControlOrder => $organizerTicketControlOrder);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketsApi->organizerTicketsControlEventsPost: $@\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.TicketsApi()
organizerTicketControlOrder =  # array[OrganizerTicketControlOrder] | 

try:
    # Ticket update
    api_response = api_instance.organizer_tickets_control_events_post(organizerTicketControlOrder)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->organizerTicketsControlEventsPost: %s\n" % e)

extern crate TicketsApi;

pub fn main() {
    let organizerTicketControlOrder = ; // array[OrganizerTicketControlOrder]

    let mut context = TicketsApi::Context::default();
    let result = client.organizerTicketsControlEventsPost(organizerTicketControlOrder, &context).wait();

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.TicketsApi;

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

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

        // Create an instance of the API class
        TicketsApi apiInstance = new TicketsApi();
        array[OrganizerTicketDeleteOrder] organizerTicketDeleteOrder = ; // array[OrganizerTicketDeleteOrder] | 

        try {
            array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsDeleteEventsPost(organizerTicketDeleteOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsDeleteEventsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[OrganizerTicketDeleteOrder] organizerTicketDeleteOrder = new array[OrganizerTicketDeleteOrder](); // array[OrganizerTicketDeleteOrder] | 

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

import com.secutix.tixngo.v4.0.api.TicketsApi;

public class TicketsApiExample {
    public static void main(String[] args) {
        TicketsApi apiInstance = new TicketsApi();
        array[OrganizerTicketDeleteOrder] organizerTicketDeleteOrder = ; // array[OrganizerTicketDeleteOrder] | 

        try {
            array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsDeleteEventsPost(organizerTicketDeleteOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsDeleteEventsPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TicketsApi *apiInstance = [[TicketsApi alloc] init];
array[OrganizerTicketDeleteOrder] *organizerTicketDeleteOrder = ; // 

// Ticket update
[apiInstance organizerTicketsDeleteEventsPostWith:organizerTicketDeleteOrder
              completionHandler: ^(array[OrganizerTicketInterfaceResponseEntry] 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.TicketsApi()
var organizerTicketDeleteOrder = ; // {array[OrganizerTicketDeleteOrder]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketsApi();
            var organizerTicketDeleteOrder = new array[OrganizerTicketDeleteOrder](); // array[OrganizerTicketDeleteOrder] | 

            try {
                // Ticket update
                array[OrganizerTicketInterfaceResponseEntry] result = apiInstance.organizerTicketsDeleteEventsPost(organizerTicketDeleteOrder);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketsApi.organizerTicketsDeleteEventsPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketsApi();
$organizerTicketDeleteOrder = ; // array[OrganizerTicketDeleteOrder] | 

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

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

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

eval {
    my $result = $api_instance->organizerTicketsDeleteEventsPost(organizerTicketDeleteOrder => $organizerTicketDeleteOrder);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketsApi->organizerTicketsDeleteEventsPost: $@\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.TicketsApi()
organizerTicketDeleteOrder =  # array[OrganizerTicketDeleteOrder] | 

try:
    # Ticket update
    api_response = api_instance.organizer_tickets_delete_events_post(organizerTicketDeleteOrder)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->organizerTicketsDeleteEventsPost: %s\n" % e)

extern crate TicketsApi;

pub fn main() {
    let organizerTicketDeleteOrder = ; // array[OrganizerTicketDeleteOrder]

    let mut context = TicketsApi::Context::default();
    let result = client.organizerTicketsDeleteEventsPost(organizerTicketDeleteOrder, &context).wait();

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.TicketsApi;

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

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

        // Create an instance of the API class
        TicketsApi apiInstance = new TicketsApi();
        String previousSetId = previousSetId_example; // String | 

        try {
            SetOfChanges result = apiInstance.organizerTicketsDiffGet(previousSetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsDiffGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import com.secutix.tixngo.v4.0.api.TicketsApi;

public class TicketsApiExample {
    public static void main(String[] args) {
        TicketsApi apiInstance = new TicketsApi();
        String previousSetId = previousSetId_example; // String | 

        try {
            SetOfChanges result = apiInstance.organizerTicketsDiffGet(previousSetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsDiffGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TicketsApi *apiInstance = [[TicketsApi alloc] init];
String *previousSetId = previousSetId_example; //  (optional) (default to null)

[apiInstance organizerTicketsDiffGetWith:previousSetId
              completionHandler: ^(SetOfChanges 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.TicketsApi()
var opts = {
  'previousSetId': previousSetId_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketsApi();
            var previousSetId = previousSetId_example;  // String |  (optional)  (default to null)

            try {
                SetOfChanges result = apiInstance.organizerTicketsDiffGet(previousSetId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketsApi.organizerTicketsDiffGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketsApi();
$previousSetId = previousSetId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketsApi->new();
my $previousSetId = previousSetId_example; # String | 

eval {
    my $result = $api_instance->organizerTicketsDiffGet(previousSetId => $previousSetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketsApi->organizerTicketsDiffGet: $@\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.TicketsApi()
previousSetId = previousSetId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.organizer_tickets_diff_get(previousSetId=previousSetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->organizerTicketsDiffGet: %s\n" % e)

extern crate TicketsApi;

pub fn main() {
    let previousSetId = previousSetId_example; // String

    let mut context = TicketsApi::Context::default();
    let result = client.organizerTicketsDiffGet(previousSetId, &context).wait();

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

import com.secutix.tixngo.v4.0.*;
import com.secutix.tixngo.v4.0.auth.*;
import com.secutix.tixngo.v4.0.model.*;
import com.secutix.tixngo.v4.0.api.TicketsApi;

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

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

        // Create an instance of the API class
        TicketsApi apiInstance = new TicketsApi();
        String actor = actor_example; // String | 
        OrganizerInjectTicketRequest organizerInjectTicketRequest = ; // OrganizerInjectTicketRequest | 

        try {
            array[OrganizerInjectTicketResponseEntry] result = apiInstance.organizerTicketsPost(actor, organizerInjectTicketRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String actor = new String(); // String | 
final OrganizerInjectTicketRequest organizerInjectTicketRequest = new OrganizerInjectTicketRequest(); // OrganizerInjectTicketRequest | 

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

import com.secutix.tixngo.v4.0.api.TicketsApi;

public class TicketsApiExample {
    public static void main(String[] args) {
        TicketsApi apiInstance = new TicketsApi();
        String actor = actor_example; // String | 
        OrganizerInjectTicketRequest organizerInjectTicketRequest = ; // OrganizerInjectTicketRequest | 

        try {
            array[OrganizerInjectTicketResponseEntry] result = apiInstance.organizerTicketsPost(actor, organizerInjectTicketRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketsApi#organizerTicketsPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TicketsApi *apiInstance = [[TicketsApi alloc] init];
String *actor = actor_example; //  (optional) (default to S360)
OrganizerInjectTicketRequest *organizerInjectTicketRequest = ; //  (optional)

// Ticket injection
[apiInstance organizerTicketsPostWith:actor
    organizerInjectTicketRequest:organizerInjectTicketRequest
              completionHandler: ^(array[OrganizerInjectTicketResponseEntry] 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.TicketsApi()
var opts = {
  'actor': actor_example, // {String} 
  'organizerInjectTicketRequest':  // {OrganizerInjectTicketRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketsApi();
            var actor = actor_example;  // String |  (optional)  (default to S360)
            var organizerInjectTicketRequest = new OrganizerInjectTicketRequest(); // OrganizerInjectTicketRequest |  (optional) 

            try {
                // Ticket injection
                array[OrganizerInjectTicketResponseEntry] result = apiInstance.organizerTicketsPost(actor, organizerInjectTicketRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketsApi.organizerTicketsPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketsApi();
$actor = actor_example; // String | 
$organizerInjectTicketRequest = ; // OrganizerInjectTicketRequest | 

try {
    $result = $api_instance->organizerTicketsPost($actor, $organizerInjectTicketRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TicketsApi->organizerTicketsPost: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketsApi->new();
my $actor = actor_example; # String | 
my $organizerInjectTicketRequest = WWW::OPenAPIClient::Object::OrganizerInjectTicketRequest->new(); # OrganizerInjectTicketRequest | 

eval {
    my $result = $api_instance->organizerTicketsPost(actor => $actor, organizerInjectTicketRequest => $organizerInjectTicketRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketsApi->organizerTicketsPost: $@\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.TicketsApi()
actor = actor_example # String |  (optional) (default to S360)
organizerInjectTicketRequest =  # OrganizerInjectTicketRequest |  (optional)

try:
    # Ticket injection
    api_response = api_instance.organizer_tickets_post(actor=actor, organizerInjectTicketRequest=organizerInjectTicketRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketsApi->organizerTicketsPost: %s\n" % e)

extern crate TicketsApi;

pub fn main() {
    let actor = actor_example; // String
    let organizerInjectTicketRequest = ; // OrganizerInjectTicketRequest

    let mut context = TicketsApi::Context::default();
    let result = client.organizerTicketsPost(actor, organizerInjectTicketRequest, &context).wait();

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