import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        
        try {
            apiInstance.costIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        
        try {
            apiInstance.costIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the cost-object (default to null)

// This method deletes all cost objects associated with an event
[apiInstance costIdDeleteWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the cost-object

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

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

namespace Example
{
    public class costIdDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the cost-object (default to null)

            try {
                // This method deletes all cost objects associated with an event
                apiInstance.costIdDelete(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.costIdDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the cost-object

try {
    $api_instance->costIdDelete($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->costIdDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the cost-object

eval { 
    $api_instance->costIdDelete(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->costIdDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the cost-object (default to null)

try: 
    # This method deletes all cost objects associated with an event
    api_instance.cost_id_delete(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->costIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.costIdDelete(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        
        try {
            Cost result = apiInstance.costIdGet(auth, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        
        try {
            Cost result = apiInstance.costIdGet(auth, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the cost-object (default to null)

// just to create test data
[apiInstance costIdGetWith:auth
    id:id
              completionHandler: ^(Cost output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the cost-object

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

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

namespace Example
{
    public class costIdGetExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the cost-object (default to null)

            try {
                // just to create test data
                Cost result = apiInstance.costIdGet(auth, id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.costIdGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the cost-object

try {
    $result = $api_instance->costIdGet($auth, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->costIdGet: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the cost-object

eval { 
    my $result = $api_instance->costIdGet(auth => $auth, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->costIdGet: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the cost-object (default to null)

try: 
    # just to create test data
    api_response = api_instance.cost_id_get(auth, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->costIdGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.costIdGet(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the Cost-object
        Cost cost = ; // Cost | 
        
        try {
            apiInstance.costIdPost(auth, id, cost);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the Cost-object
        Cost cost = ; // Cost | 
        
        try {
            apiInstance.costIdPost(auth, id, cost);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the Cost-object (default to null)
Cost *cost = ; // 

// This method creates or updates event cost
[apiInstance costIdPostWith:auth
    id:id
    cost:cost
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the Cost-object
var cost = ; // {Cost} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.costIdPost(auth, id, cost, callback);

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

namespace Example
{
    public class costIdPostExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the Cost-object (default to null)
            var cost = new Cost(); // Cost | 

            try {
                // This method creates or updates event cost
                apiInstance.costIdPost(auth, id, cost);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.costIdPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the Cost-object
$cost = ; // Cost | 

try {
    $api_instance->costIdPost($auth, $id, $cost);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->costIdPost: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the Cost-object
my $cost = WWW::OPenAPIClient::Object::Cost->new(); # Cost | 

eval { 
    $api_instance->costIdPost(auth => $auth, id => $id, cost => $cost);
};
if ($@) {
    warn "Exception when calling DefaultApi->costIdPost: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the Cost-object (default to null)
cost =  # Cost | 

try: 
    # This method creates or updates event cost
    api_instance.cost_id_post(auth, id, cost)
except ApiException as e:
    print("Exception when calling DefaultApi->costIdPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer
    let cost = ; // Cost

    let mut context = DefaultApi::Context::default();
    let result = client.costIdPost(auth, id, cost, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        Integer type = 56; // Integer | Cost-object type as defined by the data model
        
        try {
            apiInstance.costIdTypeDelete(auth, id, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdTypeDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the cost-object
        Integer type = 56; // Integer | Cost-object type as defined by the data model
        
        try {
            apiInstance.costIdTypeDelete(auth, id, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#costIdTypeDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the cost-object (default to null)
Integer *type = 56; // Cost-object type as defined by the data model (default to null)

// This method deletes an event cost object
[apiInstance costIdTypeDeleteWith:auth
    id:id
    type:type
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the cost-object
var type = 56; // {Integer} Cost-object type as defined by the data model

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.costIdTypeDelete(auth, id, type, callback);

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

namespace Example
{
    public class costIdTypeDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the cost-object (default to null)
            var type = 56;  // Integer | Cost-object type as defined by the data model (default to null)

            try {
                // This method deletes an event cost object
                apiInstance.costIdTypeDelete(auth, id, type);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.costIdTypeDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the cost-object
$type = 56; // Integer | Cost-object type as defined by the data model

try {
    $api_instance->costIdTypeDelete($auth, $id, $type);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->costIdTypeDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the cost-object
my $type = 56; # Integer | Cost-object type as defined by the data model

eval { 
    $api_instance->costIdTypeDelete(auth => $auth, id => $id, type => $type);
};
if ($@) {
    warn "Exception when calling DefaultApi->costIdTypeDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the cost-object (default to null)
type = 56 # Integer | Cost-object type as defined by the data model (default to null)

try: 
    # This method deletes an event cost object
    api_instance.cost_id_type_delete(auth, id, type)
except ApiException as e:
    print("Exception when calling DefaultApi->costIdTypeDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer
    let type = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.costIdTypeDelete(auth, id, type, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        
        try {
            apiInstance.eventsActivateIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsActivateIdDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        
        try {
            apiInstance.eventsActivateIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsActivateIdDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
String *id = id_example; // Unique identifier of the event returned on event creation. (default to null)

// This method deactivates an event
[apiInstance eventsActivateIdDeleteWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = id_example; // {String} Unique identifier of the event returned on event creation.

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

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

namespace Example
{
    public class eventsActivateIdDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = id_example;  // String | Unique identifier of the event returned on event creation. (default to null)

            try {
                // This method deactivates an event
                apiInstance.eventsActivateIdDelete(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsActivateIdDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = id_example; // String | Unique identifier of the event returned on event creation.

try {
    $api_instance->eventsActivateIdDelete($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsActivateIdDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = id_example; # String | Unique identifier of the event returned on event creation.

eval { 
    $api_instance->eventsActivateIdDelete(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsActivateIdDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = id_example # String | Unique identifier of the event returned on event creation. (default to null)

try: 
    # This method deactivates an event
    api_instance.events_activate_id_delete(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsActivateIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.eventsActivateIdDelete(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        
        try {
            apiInstance.eventsActivateIdPut(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsActivateIdPut");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        
        try {
            apiInstance.eventsActivateIdPut(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsActivateIdPut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
String *id = id_example; // Unique identifier of the event returned on event creation. (default to null)

// This method activates an event
[apiInstance eventsActivateIdPutWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = id_example; // {String} Unique identifier of the event returned on event creation.

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

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

namespace Example
{
    public class eventsActivateIdPutExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = id_example;  // String | Unique identifier of the event returned on event creation. (default to null)

            try {
                // This method activates an event
                apiInstance.eventsActivateIdPut(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsActivateIdPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = id_example; // String | Unique identifier of the event returned on event creation.

try {
    $api_instance->eventsActivateIdPut($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsActivateIdPut: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = id_example; # String | Unique identifier of the event returned on event creation.

eval { 
    $api_instance->eventsActivateIdPut(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsActivateIdPut: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = id_example # String | Unique identifier of the event returned on event creation. (default to null)

try: 
    # This method activates an event
    api_instance.events_activate_id_put(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsActivateIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.eventsActivateIdPut(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

import org.openapitools.client.api.DefaultApi;

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

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

// just to create test data
[apiInstance eventsGetWithCompletionHandler: 
              ^(Event output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

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

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

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

            try {
                // just to create test data
                Event result = apiInstance.eventsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsGet: " + 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->eventsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsGet: ', $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->eventsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsGet: $@\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: 
    # just to create test data
    api_response = api_instance.events_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation
        
        try {
            apiInstance.eventsIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsIdDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation
        
        try {
            apiInstance.eventsIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsIdDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
String *id = id_example; // Unique identifier of the event returned on event creation (default to null)

// This method deletes an event
[apiInstance eventsIdDeleteWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = id_example; // {String} Unique identifier of the event returned on event creation

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

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

namespace Example
{
    public class eventsIdDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = id_example;  // String | Unique identifier of the event returned on event creation (default to null)

            try {
                // This method deletes an event
                apiInstance.eventsIdDelete(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsIdDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = id_example; // String | Unique identifier of the event returned on event creation

try {
    $api_instance->eventsIdDelete($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsIdDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = id_example; # String | Unique identifier of the event returned on event creation

eval { 
    $api_instance->eventsIdDelete(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsIdDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = id_example # String | Unique identifier of the event returned on event creation (default to null)

try: 
    # This method deletes an event
    api_instance.events_id_delete(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = id_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.eventsIdDelete(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        Event event = ; // Event | 
        
        try {
            apiInstance.eventsIdPut(auth, id, event);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsIdPut");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        String id = id_example; // String | Unique identifier of the event returned on event creation.
        Event event = ; // Event | 
        
        try {
            apiInstance.eventsIdPut(auth, id, event);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsIdPut");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
String *id = id_example; // Unique identifier of the event returned on event creation. (default to null)
Event *event = ; // 

// This method updates selected fileds of an event
[apiInstance eventsIdPutWith:auth
    id:id
    event:event
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = id_example; // {String} Unique identifier of the event returned on event creation.
var event = ; // {Event} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.eventsIdPut(auth, id, event, callback);

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

namespace Example
{
    public class eventsIdPutExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = id_example;  // String | Unique identifier of the event returned on event creation. (default to null)
            var event = new Event(); // Event | 

            try {
                // This method updates selected fileds of an event
                apiInstance.eventsIdPut(auth, id, event);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsIdPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = id_example; // String | Unique identifier of the event returned on event creation.
$event = ; // Event | 

try {
    $api_instance->eventsIdPut($auth, $id, $event);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsIdPut: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = id_example; # String | Unique identifier of the event returned on event creation.
my $event = WWW::OPenAPIClient::Object::Event->new(); # Event | 

eval { 
    $api_instance->eventsIdPut(auth => $auth, id => $id, event => $event);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsIdPut: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = id_example # String | Unique identifier of the event returned on event creation. (default to null)
event =  # Event | 

try: 
    # This method updates selected fileds of an event
    api_instance.events_id_put(auth, id, event)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsIdPut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = id_example; // String
    let event = ; // Event

    let mut context = DefaultApi::Context::default();
    let result = client.eventsIdPut(auth, id, event, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Event event = ; // Event | 
        
        try {
            apiInstance.eventsPost(auth, event);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Event event = ; // Event | 
        
        try {
            apiInstance.eventsPost(auth, event);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#eventsPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Event *event = ; // 

// This method creates a new event
[apiInstance eventsPostWith:auth
    event:event
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var event = ; // {Event} 

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

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

namespace Example
{
    public class eventsPostExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var event = new Event(); // Event | 

            try {
                // This method creates a new event
                apiInstance.eventsPost(auth, event);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.eventsPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$event = ; // Event | 

try {
    $api_instance->eventsPost($auth, $event);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->eventsPost: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $event = WWW::OPenAPIClient::Object::Event->new(); # Event | 

eval { 
    $api_instance->eventsPost(auth => $auth, event => $event);
};
if ($@) {
    warn "Exception when calling DefaultApi->eventsPost: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
event =  # Event | 

try: 
    # This method creates a new event
    api_instance.events_post(auth, event)
except ApiException as e:
    print("Exception when calling DefaultApi->eventsPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let event = ; // Event

    let mut context = DefaultApi::Context::default();
    let result = client.eventsPost(auth, event, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        String filename = filename_example; // String | filename of the file to delete
        
        try {
            apiInstance.filesIdFilenameDelete(auth, id, filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#filesIdFilenameDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        String filename = filename_example; // String | filename of the file to delete
        
        try {
            apiInstance.filesIdFilenameDelete(auth, id, filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#filesIdFilenameDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the file target (default to null)
String *filename = filename_example; // filename of the file to delete (default to null)

// This method deletes an event attachment
[apiInstance filesIdFilenameDeleteWith:auth
    id:id
    filename:filename
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the file target
var filename = filename_example; // {String} filename of the file to delete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.filesIdFilenameDelete(auth, id, filename, callback);

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

namespace Example
{
    public class filesIdFilenameDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the file target (default to null)
            var filename = filename_example;  // String | filename of the file to delete (default to null)

            try {
                // This method deletes an event attachment
                apiInstance.filesIdFilenameDelete(auth, id, filename);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.filesIdFilenameDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the file target
$filename = filename_example; // String | filename of the file to delete

try {
    $api_instance->filesIdFilenameDelete($auth, $id, $filename);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->filesIdFilenameDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the file target
my $filename = filename_example; # String | filename of the file to delete

eval { 
    $api_instance->filesIdFilenameDelete(auth => $auth, id => $id, filename => $filename);
};
if ($@) {
    warn "Exception when calling DefaultApi->filesIdFilenameDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the file target (default to null)
filename = filename_example # String | filename of the file to delete (default to null)

try: 
    # This method deletes an event attachment
    api_instance.files_id_filename_delete(auth, id, filename)
except ApiException as e:
    print("Exception when calling DefaultApi->filesIdFilenameDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer
    let filename = filename_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.filesIdFilenameDelete(auth, id, filename, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        String linkName = linkName_example; // String | Text that should be displayed when showing the image
        String fileName = fileName_example; // String | Filename with oder identifier (separated with an _)
        File attachment = BINARY_DATA_HERE; // File | The attachment to add
        
        try {
            apiInstance.filesIdPost(auth, id, linkName, fileName, attachment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#filesIdPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        String linkName = linkName_example; // String | Text that should be displayed when showing the image
        String fileName = fileName_example; // String | Filename with oder identifier (separated with an _)
        File attachment = BINARY_DATA_HERE; // File | The attachment to add
        
        try {
            apiInstance.filesIdPost(auth, id, linkName, fileName, attachment);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#filesIdPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the file target (default to null)
String *linkName = linkName_example; // Text that should be displayed when showing the image (default to null)
String *fileName = fileName_example; // Filename with oder identifier (separated with an _) (default to null)
File *attachment = BINARY_DATA_HERE; // The attachment to add (default to null)

// This method creates or updates an event attachment
[apiInstance filesIdPostWith:auth
    id:id
    linkName:linkName
    fileName:fileName
    attachment:attachment
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the file target
var linkName = linkName_example; // {String} Text that should be displayed when showing the image
var fileName = fileName_example; // {String} Filename with oder identifier (separated with an _)
var attachment = BINARY_DATA_HERE; // {File} The attachment to add

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.filesIdPost(auth, id, linkName, fileName, attachment, callback);

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

namespace Example
{
    public class filesIdPostExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the file target (default to null)
            var linkName = linkName_example;  // String | Text that should be displayed when showing the image (default to null)
            var fileName = fileName_example;  // String | Filename with oder identifier (separated with an _) (default to null)
            var attachment = BINARY_DATA_HERE;  // File | The attachment to add (default to null)

            try {
                // This method creates or updates an event attachment
                apiInstance.filesIdPost(auth, id, linkName, fileName, attachment);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.filesIdPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the file target
$linkName = linkName_example; // String | Text that should be displayed when showing the image
$fileName = fileName_example; // String | Filename with oder identifier (separated with an _)
$attachment = BINARY_DATA_HERE; // File | The attachment to add

try {
    $api_instance->filesIdPost($auth, $id, $linkName, $fileName, $attachment);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->filesIdPost: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the file target
my $linkName = linkName_example; # String | Text that should be displayed when showing the image
my $fileName = fileName_example; # String | Filename with oder identifier (separated with an _)
my $attachment = BINARY_DATA_HERE; # File | The attachment to add

eval { 
    $api_instance->filesIdPost(auth => $auth, id => $id, linkName => $linkName, fileName => $fileName, attachment => $attachment);
};
if ($@) {
    warn "Exception when calling DefaultApi->filesIdPost: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the file target (default to null)
linkName = linkName_example # String | Text that should be displayed when showing the image (default to null)
fileName = fileName_example # String | Filename with oder identifier (separated with an _) (default to null)
attachment = BINARY_DATA_HERE # File | The attachment to add (default to null)

try: 
    # This method creates or updates an event attachment
    api_instance.files_id_post(auth, id, linkName, fileName, attachment)
except ApiException as e:
    print("Exception when calling DefaultApi->filesIdPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer
    let linkName = linkName_example; // String
    let fileName = fileName_example; // String
    let attachment = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.filesIdPost(auth, id, linkName, fileName, attachment, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

import org.openapitools.client.api.DefaultApi;

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

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

// Get application status
[apiInstance heartbeatGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        
        try {
            apiInstance.imagesIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#imagesIdDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        
        try {
            apiInstance.imagesIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#imagesIdDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the file target (default to null)

// This method deletes the image of event 
[apiInstance imagesIdDeleteWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the file target

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

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

namespace Example
{
    public class imagesIdDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the file target (default to null)

            try {
                // This method deletes the image of event 
                apiInstance.imagesIdDelete(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.imagesIdDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the file target

try {
    $api_instance->imagesIdDelete($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->imagesIdDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the file target

eval { 
    $api_instance->imagesIdDelete(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->imagesIdDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the file target (default to null)

try: 
    # This method deletes the image of event 
    api_instance.images_id_delete(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->imagesIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.imagesIdDelete(auth, id, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        File file = BINARY_DATA_HERE; // File | 
        
        try {
            apiInstance.imagesIdPost(auth, id, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#imagesIdPost");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Eventid for the file target
        File file = BINARY_DATA_HERE; // File | 
        
        try {
            apiInstance.imagesIdPost(auth, id, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#imagesIdPost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Eventid for the file target (default to null)
File *file = BINARY_DATA_HERE; //  (default to null)

// This method creates or updates an event image
[apiInstance imagesIdPostWith:auth
    id:id
    file:file
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Eventid for the file target
var file = BINARY_DATA_HERE; // {File} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.imagesIdPost(auth, id, file, callback);

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

namespace Example
{
    public class imagesIdPostExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Eventid for the file target (default to null)
            var file = BINARY_DATA_HERE;  // File |  (default to null)

            try {
                // This method creates or updates an event image
                apiInstance.imagesIdPost(auth, id, file);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.imagesIdPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Eventid for the file target
$file = BINARY_DATA_HERE; // File | 

try {
    $api_instance->imagesIdPost($auth, $id, $file);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->imagesIdPost: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Eventid for the file target
my $file = BINARY_DATA_HERE; # File | 

eval { 
    $api_instance->imagesIdPost(auth => $auth, id => $id, file => $file);
};
if ($@) {
    warn "Exception when calling DefaultApi->imagesIdPost: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Eventid for the file target (default to null)
file = BINARY_DATA_HERE # File |  (default to null)

try: 
    # This method creates or updates an event image
    api_instance.images_id_post(auth, id, file)
except ApiException as e:
    print("Exception when calling DefaultApi->imagesIdPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer
    let file = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.imagesIdPost(auth, id, file, &context).wait();

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        
        try {
            Registration result = apiInstance.registrationsGet(auth);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registrationsGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        
        try {
            Registration result = apiInstance.registrationsGet(auth);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registrationsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)

// This method returns the oldest not yet delivered registartion
[apiInstance registrationsGetWith:auth
              completionHandler: ^(Registration output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token

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

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

namespace Example
{
    public class registrationsGetExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)

            try {
                // This method returns the oldest not yet delivered registartion
                Registration result = apiInstance.registrationsGet(auth);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.registrationsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token

try {
    $result = $api_instance->registrationsGet($auth);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->registrationsGet: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token

eval { 
    my $result = $api_instance->registrationsGet(auth => $auth);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->registrationsGet: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)

try: 
    # This method returns the oldest not yet delivered registartion
    api_response = api_instance.registrations_get(auth)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->registrationsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String

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

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

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Unique identifier of the registration received on getting the registration
        
        try {
            apiInstance.registrationsIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registrationsIdDelete");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String auth = auth_example; // String | an authorization header containing a predefined secret token
        Integer id = 56; // Integer | Unique identifier of the registration received on getting the registration
        
        try {
            apiInstance.registrationsIdDelete(auth, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#registrationsIdDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *auth = auth_example; // an authorization header containing a predefined secret token (default to null)
Integer *id = 56; // Unique identifier of the registration received on getting the registration (default to null)

// This method deletes a registration
[apiInstance registrationsIdDeleteWith:auth
    id:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ManiacMan = require('maniac_man');

// Create an instance of the API class
var api = new ManiacMan.DefaultApi()
var auth = auth_example; // {String} an authorization header containing a predefined secret token
var id = 56; // {Integer} Unique identifier of the registration received on getting the registration

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

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

namespace Example
{
    public class registrationsIdDeleteExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var auth = auth_example;  // String | an authorization header containing a predefined secret token (default to null)
            var id = 56;  // Integer | Unique identifier of the registration received on getting the registration (default to null)

            try {
                // This method deletes a registration
                apiInstance.registrationsIdDelete(auth, id);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.registrationsIdDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$auth = auth_example; // String | an authorization header containing a predefined secret token
$id = 56; // Integer | Unique identifier of the registration received on getting the registration

try {
    $api_instance->registrationsIdDelete($auth, $id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->registrationsIdDelete: ', $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 $auth = auth_example; # String | an authorization header containing a predefined secret token
my $id = 56; # Integer | Unique identifier of the registration received on getting the registration

eval { 
    $api_instance->registrationsIdDelete(auth => $auth, id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->registrationsIdDelete: $@\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()
auth = auth_example # String | an authorization header containing a predefined secret token (default to null)
id = 56 # Integer | Unique identifier of the registration received on getting the registration (default to null)

try: 
    # This method deletes a registration
    api_instance.registrations_id_delete(auth, id)
except ApiException as e:
    print("Exception when calling DefaultApi->registrationsIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let auth = auth_example; // String
    let id = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.registrationsIdDelete(auth, id, &context).wait();

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