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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

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

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

// For best performance, send empty room reset while the room is empty.
[apiInstance appEmptyRoomCalibrationPostWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // For best performance, send empty room reset while the room is empty.
                apiInstance.appEmptyRoomCalibrationPost();
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appEmptyRoomCalibrationPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    $api_instance->appEmptyRoomCalibrationPost();
};
if ($@) {
    warn "Exception when calling AppApi->appEmptyRoomCalibrationPost: $@\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.AppApi()

try:
    # For best performance, send empty room reset while the room is empty.
    api_instance.app_empty_room_calibration_post()
except ApiException as e:
    print("Exception when calling AppApi->appEmptyRoomCalibrationPost: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appEmptyRoomCalibrationPost(&context).wait();

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

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

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

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

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

        try {
            Zones result = apiInstance.appExclusionZonesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appExclusionZonesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            Zones result = apiInstance.appExclusionZonesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appExclusionZonesGet");
            e.printStackTrace();
        }
    }
}

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

// Requests the exclusion zone definitions
[apiInstance appExclusionZonesGetWithCompletionHandler: 
              ^(Zones output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Requests the exclusion zone definitions
                Zones result = apiInstance.appExclusionZonesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appExclusionZonesGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appExclusionZonesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appExclusionZonesGet: $@\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.AppApi()

try:
    # Requests the exclusion zone definitions
    api_response = api_instance.app_exclusion_zones_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appExclusionZonesGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appExclusionZonesGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AppApi apiInstance = new AppApi();
        Zones zones = ; // Zones | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Zones zones = new Zones(); // Zones | 

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

import org.openapitools.client.api.AppApi;

public class AppApiExample {
    public static void main(String[] args) {
        AppApi apiInstance = new AppApi();
        Zones zones = ; // Zones | 

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

// Create an instance of the API class
AppApi *apiInstance = [[AppApi alloc] init];
Zones *zones = ; //  (optional)

// Updates the exclusion zone definitions
[apiInstance appExclusionZonesPutWith:zones
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.AppApi()
var opts = {
  'zones':  // {Zones} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AppApi();
            var zones = new Zones(); // Zones |  (optional) 

            try {
                // Updates the exclusion zone definitions
                apiInstance.appExclusionZonesPut(zones);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appExclusionZonesPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();
$zones = ; // Zones | 

try {
    $api_instance->appExclusionZonesPut($zones);
} catch (Exception $e) {
    echo 'Exception when calling AppApi->appExclusionZonesPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();
my $zones = WWW::OPenAPIClient::Object::Zones->new(); # Zones | 

eval {
    $api_instance->appExclusionZonesPut(zones => $zones);
};
if ($@) {
    warn "Exception when calling AppApi->appExclusionZonesPut: $@\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.AppApi()
zones =  # Zones |  (optional)

try:
    # Updates the exclusion zone definitions
    api_instance.app_exclusion_zones_put(zones=zones)
except ApiException as e:
    print("Exception when calling AppApi->appExclusionZonesPut: %s\n" % e)

extern crate AppApi;

pub fn main() {
    let zones = ; // Zones

    let mut context = AppApi::Context::default();
    let result = client.appExclusionZonesPut(zones, &context).wait();

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

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

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

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

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

        try {
            DeviceInfo result = apiInstance.appInfoGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appInfoGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            DeviceInfo result = apiInstance.appInfoGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appInfoGet");
            e.printStackTrace();
        }
    }
}

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

// Queries device information.
[apiInstance appInfoGetWithCompletionHandler: 
              ^(DeviceInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries device information.
                DeviceInfo result = apiInstance.appInfoGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appInfoGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appInfoGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appInfoGet: $@\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.AppApi()

try:
    # Queries device information.
    api_response = api_instance.app_info_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appInfoGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appInfoGet(&context).wait();

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

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

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

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

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

        try {
            File result = apiInstance.appOcclusionImageGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appOcclusionImageGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            File result = apiInstance.appOcclusionImageGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appOcclusionImageGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the current occlusion image
[apiInstance appOcclusionImageGetWithCompletionHandler: 
              ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the current occlusion image
                File result = apiInstance.appOcclusionImageGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appOcclusionImageGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appOcclusionImageGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appOcclusionImageGet: $@\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.AppApi()

try:
    # Queries the current occlusion image
    api_response = api_instance.app_occlusion_image_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appOcclusionImageGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appOcclusionImageGet(&context).wait();

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

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

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

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

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

        try {
            Occupancy result = apiInstance.appOccupancyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appOccupancyGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            Occupancy result = apiInstance.appOccupancyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appOccupancyGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the presence in the room
[apiInstance appOccupancyGetWithCompletionHandler: 
              ^(Occupancy output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the presence in the room
                Occupancy result = apiInstance.appOccupancyGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appOccupancyGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appOccupancyGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appOccupancyGet: $@\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.AppApi()

try:
    # Queries the presence in the room
    api_response = api_instance.app_occupancy_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appOccupancyGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appOccupancyGet(&context).wait();

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

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

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

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

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

        try {
            PeopleCount result = apiInstance.appPeopleCountGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appPeopleCountGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            PeopleCount result = apiInstance.appPeopleCountGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appPeopleCountGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the number of people in the room
[apiInstance appPeopleCountGetWithCompletionHandler: 
              ^(PeopleCount output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the number of people in the room
                PeopleCount result = apiInstance.appPeopleCountGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appPeopleCountGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appPeopleCountGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appPeopleCountGet: $@\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.AppApi()

try:
    # Queries the number of people in the room
    api_response = api_instance.app_people_count_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appPeopleCountGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appPeopleCountGet(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

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

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

// Queries people's location
[apiInstance appPeopleLocationGetWithCompletionHandler: 
              ^(array[Coordinate] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries people's location
                array[Coordinate] result = apiInstance.appPeopleLocationGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appPeopleLocationGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appPeopleLocationGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appPeopleLocationGet: $@\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.AppApi()

try:
    # Queries people's location
    api_response = api_instance.app_people_location_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appPeopleLocationGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appPeopleLocationGet(&context).wait();

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

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

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

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

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

        try {
            RoomHeight result = apiInstance.appRoomHeightGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appRoomHeightGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            RoomHeight result = apiInstance.appRoomHeightGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appRoomHeightGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the room height.
[apiInstance appRoomHeightGetWithCompletionHandler: 
              ^(RoomHeight output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the room height.
                RoomHeight result = apiInstance.appRoomHeightGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appRoomHeightGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appRoomHeightGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appRoomHeightGet: $@\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.AppApi()

try:
    # Queries the room height.
    api_response = api_instance.app_room_height_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appRoomHeightGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appRoomHeightGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AppApi apiInstance = new AppApi();
        Integer roomHeight = 56; // Integer | The new value of the room height

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer roomHeight = new Integer(); // Integer | The new value of the room height

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

import org.openapitools.client.api.AppApi;

public class AppApiExample {
    public static void main(String[] args) {
        AppApi apiInstance = new AppApi();
        Integer roomHeight = 56; // Integer | The new value of the room height

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

// Create an instance of the API class
AppApi *apiInstance = [[AppApi alloc] init];
Integer *roomHeight = 56; // The new value of the room height (default to null)

// Sets room height.
[apiInstance appRoomHeightRoomHeightPutWith:roomHeight
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.AppApi()
var roomHeight = 56; // {Integer} The new value of the room height

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

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

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

            // Create an instance of the API class
            var apiInstance = new AppApi();
            var roomHeight = 56;  // Integer | The new value of the room height (default to null)

            try {
                // Sets room height.
                apiInstance.appRoomHeightRoomHeightPut(roomHeight);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appRoomHeightRoomHeightPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();
$roomHeight = 56; // Integer | The new value of the room height

try {
    $api_instance->appRoomHeightRoomHeightPut($roomHeight);
} catch (Exception $e) {
    echo 'Exception when calling AppApi->appRoomHeightRoomHeightPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();
my $roomHeight = 56; # Integer | The new value of the room height

eval {
    $api_instance->appRoomHeightRoomHeightPut(roomHeight => $roomHeight);
};
if ($@) {
    warn "Exception when calling AppApi->appRoomHeightRoomHeightPut: $@\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.AppApi()
roomHeight = 56 # Integer | The new value of the room height (default to null)

try:
    # Sets room height.
    api_instance.app_room_height_room_height_put(roomHeight)
except ApiException as e:
    print("Exception when calling AppApi->appRoomHeightRoomHeightPut: %s\n" % e)

extern crate AppApi;

pub fn main() {
    let roomHeight = 56; // Integer

    let mut context = AppApi::Context::default();
    let result = client.appRoomHeightRoomHeightPut(roomHeight, &context).wait();

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

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

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

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

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

        try {
            RoomSize result = apiInstance.appRoomSizeGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appRoomSizeGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            RoomSize result = apiInstance.appRoomSizeGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appRoomSizeGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the size of the room in pixels and centimeters.
[apiInstance appRoomSizeGetWithCompletionHandler: 
              ^(RoomSize output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the size of the room in pixels and centimeters.
                RoomSize result = apiInstance.appRoomSizeGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appRoomSizeGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appRoomSizeGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appRoomSizeGet: $@\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.AppApi()

try:
    # Queries the size of the room in pixels and centimeters.
    api_response = api_instance.app_room_size_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appRoomSizeGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appRoomSizeGet(&context).wait();

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

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

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

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

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

        try {
            Status result = apiInstance.appStatusGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appStatusGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            Status result = apiInstance.appStatusGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appStatusGet");
            e.printStackTrace();
        }
    }
}

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

// Application firmware status
[apiInstance appStatusGetWithCompletionHandler: 
              ^(Status output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Application firmware status
                Status result = apiInstance.appStatusGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appStatusGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appStatusGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appStatusGet: $@\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.AppApi()

try:
    # Application firmware status
    api_response = api_instance.app_status_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appStatusGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appStatusGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AppApi apiInstance = new AppApi();
        array[File] filename = /path/to/file.txt; // array[File] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[File] filename = new array[File](); // array[File] | 

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

import org.openapitools.client.api.AppApi;

public class AppApiExample {
    public static void main(String[] args) {
        AppApi apiInstance = new AppApi();
        array[File] filename = /path/to/file.txt; // array[File] | 

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

// Create an instance of the API class
AppApi *apiInstance = [[AppApi alloc] init];
array[File] *filename = /path/to/file.txt; //  (optional) (default to null)

// Upload firmware update
[apiInstance appUpdatePostWith:filename
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.AppApi()
var opts = {
  'filename': /path/to/file.txt // {array[File]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AppApi();
            var filename = new array[File](); // array[File] |  (optional)  (default to null)

            try {
                // Upload firmware update
                apiInstance.appUpdatePost(filename);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appUpdatePost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();
$filename = /path/to/file.txt; // array[File] | 

try {
    $api_instance->appUpdatePost($filename);
} catch (Exception $e) {
    echo 'Exception when calling AppApi->appUpdatePost: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();
my $filename = [/path/to/file.txt]; # array[File] | 

eval {
    $api_instance->appUpdatePost(filename => $filename);
};
if ($@) {
    warn "Exception when calling AppApi->appUpdatePost: $@\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.AppApi()
filename = /path/to/file.txt # array[File] |  (optional) (default to null)

try:
    # Upload firmware update
    api_instance.app_update_post(filename=filename)
except ApiException as e:
    print("Exception when calling AppApi->appUpdatePost: %s\n" % e)

extern crate AppApi;

pub fn main() {
    let filename = /path/to/file.txt; // array[File]

    let mut context = AppApi::Context::default();
    let result = client.appUpdatePost(filename, &context).wait();

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

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

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

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

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

        try {
            UseCase result = apiInstance.appUseCaseGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appUseCaseGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            UseCase result = apiInstance.appUseCaseGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appUseCaseGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the use case.
[apiInstance appUseCaseGetWithCompletionHandler: 
              ^(UseCase output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the use case.
                UseCase result = apiInstance.appUseCaseGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appUseCaseGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appUseCaseGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appUseCaseGet: $@\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.AppApi()

try:
    # Queries the use case.
    api_response = api_instance.app_use_case_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appUseCaseGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appUseCaseGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AppApi apiInstance = new AppApi();
        String useCase = openSpace; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AppApi;

public class AppApiExample {
    public static void main(String[] args) {
        AppApi apiInstance = new AppApi();
        String useCase = openSpace; // String | 

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

// Create an instance of the API class
AppApi *apiInstance = [[AppApi alloc] init];
String *useCase = openSpace; //  (default to null)

// Sets the use case.
[apiInstance appUseCaseUseCasePutWith:useCase
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.AppApi()
var useCase = openSpace; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AppApi();
            var useCase = openSpace;  // String |  (default to null)

            try {
                // Sets the use case.
                apiInstance.appUseCaseUseCasePut(useCase);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appUseCaseUseCasePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();
$useCase = openSpace; // String | 

try {
    $api_instance->appUseCaseUseCasePut($useCase);
} catch (Exception $e) {
    echo 'Exception when calling AppApi->appUseCaseUseCasePut: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();
my $useCase = openSpace; # String | 

eval {
    $api_instance->appUseCaseUseCasePut(useCase => $useCase);
};
if ($@) {
    warn "Exception when calling AppApi->appUseCaseUseCasePut: $@\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.AppApi()
useCase = openSpace # String |  (default to null)

try:
    # Sets the use case.
    api_instance.app_use_case_use_case_put(useCase)
except ApiException as e:
    print("Exception when calling AppApi->appUseCaseUseCasePut: %s\n" % e)

extern crate AppApi;

pub fn main() {
    let useCase = openSpace; // String

    let mut context = AppApi::Context::default();
    let result = client.appUseCaseUseCasePut(useCase, &context).wait();

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

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

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

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

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

        try {
            Zones result = apiInstance.appZonesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appZonesGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AppApi;

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

        try {
            Zones result = apiInstance.appZonesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AppApi#appZonesGet");
            e.printStackTrace();
        }
    }
}

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

// Requests the zone definitions
[apiInstance appZonesGetWithCompletionHandler: 
              ^(Zones output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Requests the zone definitions
                Zones result = apiInstance.appZonesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appZonesGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();

eval {
    my $result = $api_instance->appZonesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AppApi->appZonesGet: $@\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.AppApi()

try:
    # Requests the zone definitions
    api_response = api_instance.app_zones_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AppApi->appZonesGet: %s\n" % e)

extern crate AppApi;

pub fn main() {

    let mut context = AppApi::Context::default();
    let result = client.appZonesGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        AppApi apiInstance = new AppApi();
        Zones zones = ; // Zones | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Zones zones = new Zones(); // Zones | 

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

import org.openapitools.client.api.AppApi;

public class AppApiExample {
    public static void main(String[] args) {
        AppApi apiInstance = new AppApi();
        Zones zones = ; // Zones | 

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

// Create an instance of the API class
AppApi *apiInstance = [[AppApi alloc] init];
Zones *zones = ; //  (optional)

// Updates the zone definitions
[apiInstance appZonesPutWith:zones
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.AppApi()
var opts = {
  'zones':  // {Zones} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AppApi();
            var zones = new Zones(); // Zones |  (optional) 

            try {
                // Updates the zone definitions
                apiInstance.appZonesPut(zones);
            } catch (Exception e) {
                Debug.Print("Exception when calling AppApi.appZonesPut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AppApi();
$zones = ; // Zones | 

try {
    $api_instance->appZonesPut($zones);
} catch (Exception $e) {
    echo 'Exception when calling AppApi->appZonesPut: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AppApi->new();
my $zones = WWW::OPenAPIClient::Object::Zones->new(); # Zones | 

eval {
    $api_instance->appZonesPut(zones => $zones);
};
if ($@) {
    warn "Exception when calling AppApi->appZonesPut: $@\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.AppApi()
zones =  # Zones |  (optional)

try:
    # Updates the zone definitions
    api_instance.app_zones_put(zones=zones)
except ApiException as e:
    print("Exception when calling AppApi->appZonesPut: %s\n" % e)

extern crate AppApi;

pub fn main() {
    let zones = ; // Zones

    let mut context = AppApi::Context::default();
    let result = client.appZonesPut(zones, &context).wait();

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

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

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

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

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

        try {
            MqttConfig result = apiInstance.mqttGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MqttApi#mqttGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.MqttApi;

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

        try {
            MqttConfig result = apiInstance.mqttGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MqttApi#mqttGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the current MQTT configuration
[apiInstance mqttGetWithCompletionHandler: 
              ^(MqttConfig output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the current MQTT configuration
                MqttConfig result = apiInstance.mqttGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MqttApi.mqttGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MqttApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MqttApi->new();

eval {
    my $result = $api_instance->mqttGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MqttApi->mqttGet: $@\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.MqttApi()

try:
    # Queries the current MQTT configuration
    api_response = api_instance.mqtt_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MqttApi->mqttGet: %s\n" % e)

extern crate MqttApi;

pub fn main() {

    let mut context = MqttApi::Context::default();
    let result = client.mqttGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        MqttApi apiInstance = new MqttApi();
        MqttConfig mqttConfig = ; // MqttConfig | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MqttConfig mqttConfig = new MqttConfig(); // MqttConfig | 

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

import org.openapitools.client.api.MqttApi;

public class MqttApiExample {
    public static void main(String[] args) {
        MqttApi apiInstance = new MqttApi();
        MqttConfig mqttConfig = ; // MqttConfig | 

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

// Create an instance of the API class
MqttApi *apiInstance = [[MqttApi alloc] init];
MqttConfig *mqttConfig = ; //  (optional)

// Set MQTT configuration
[apiInstance mqttPostWith:mqttConfig
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.MqttApi()
var opts = {
  'mqttConfig':  // {MqttConfig} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MqttApi();
            var mqttConfig = new MqttConfig(); // MqttConfig |  (optional) 

            try {
                // Set MQTT configuration
                apiInstance.mqttPost(mqttConfig);
            } catch (Exception e) {
                Debug.Print("Exception when calling MqttApi.mqttPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MqttApi();
$mqttConfig = ; // MqttConfig | 

try {
    $api_instance->mqttPost($mqttConfig);
} catch (Exception $e) {
    echo 'Exception when calling MqttApi->mqttPost: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MqttApi->new();
my $mqttConfig = WWW::OPenAPIClient::Object::MqttConfig->new(); # MqttConfig | 

eval {
    $api_instance->mqttPost(mqttConfig => $mqttConfig);
};
if ($@) {
    warn "Exception when calling MqttApi->mqttPost: $@\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.MqttApi()
mqttConfig =  # MqttConfig |  (optional)

try:
    # Set MQTT configuration
    api_instance.mqtt_post(mqttConfig=mqttConfig)
except ApiException as e:
    print("Exception when calling MqttApi->mqttPost: %s\n" % e)

extern crate MqttApi;

pub fn main() {
    let mqttConfig = ; // MqttConfig

    let mut context = MqttApi::Context::default();
    let result = client.mqttPost(mqttConfig, &context).wait();

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

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

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

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

        // Create an instance of the API class
        WebsocketApi apiInstance = new WebsocketApi();
        String pretty = pretty_example; // String | Indicates prettified JSON response. (Optional parameter.)

        try {
            AsyncMessage result = apiInstance.appWsGet(pretty);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebsocketApi#appWsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String pretty = new String(); // String | Indicates prettified JSON response. (Optional parameter.)

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

import org.openapitools.client.api.WebsocketApi;

public class WebsocketApiExample {
    public static void main(String[] args) {
        WebsocketApi apiInstance = new WebsocketApi();
        String pretty = pretty_example; // String | Indicates prettified JSON response. (Optional parameter.)

        try {
            AsyncMessage result = apiInstance.appWsGet(pretty);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WebsocketApi#appWsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
WebsocketApi *apiInstance = [[WebsocketApi alloc] init];
String *pretty = pretty_example; // Indicates prettified JSON response. (Optional parameter.) (optional) (default to null)

// WebSocket endpoint for receiving asynchronous data
[apiInstance appWsGetWith:pretty
              completionHandler: ^(AsyncMessage output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.WebsocketApi()
var opts = {
  'pretty': pretty_example // {String} Indicates prettified JSON response. (Optional parameter.)
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new WebsocketApi();
            var pretty = pretty_example;  // String | Indicates prettified JSON response. (Optional parameter.) (optional)  (default to null)

            try {
                // WebSocket endpoint for receiving asynchronous data
                AsyncMessage result = apiInstance.appWsGet(pretty);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WebsocketApi.appWsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WebsocketApi();
$pretty = pretty_example; // String | Indicates prettified JSON response. (Optional parameter.)

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WebsocketApi->new();
my $pretty = pretty_example; # String | Indicates prettified JSON response. (Optional parameter.)

eval {
    my $result = $api_instance->appWsGet(pretty => $pretty);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WebsocketApi->appWsGet: $@\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.WebsocketApi()
pretty = pretty_example # String | Indicates prettified JSON response. (Optional parameter.) (optional) (default to null)

try:
    # WebSocket endpoint for receiving asynchronous data
    api_response = api_instance.app_ws_get(pretty=pretty)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WebsocketApi->appWsGet: %s\n" % e)

extern crate WebsocketApi;

pub fn main() {
    let pretty = pretty_example; // String

    let mut context = WebsocketApi::Context::default();
    let result = client.appWsGet(pretty, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.WebsocketApi;

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

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

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

// WebSocket endpoint for receiving asynchronously people location
[apiInstance appWsPeopleLocationGetWithCompletionHandler: 
              ^(array[Coordinate] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // WebSocket endpoint for receiving asynchronously people location
                array[Coordinate] result = apiInstance.appWsPeopleLocationGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WebsocketApi.appWsPeopleLocationGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WebsocketApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WebsocketApi->new();

eval {
    my $result = $api_instance->appWsPeopleLocationGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WebsocketApi->appWsPeopleLocationGet: $@\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.WebsocketApi()

try:
    # WebSocket endpoint for receiving asynchronously people location
    api_response = api_instance.app_ws_people_location_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WebsocketApi->appWsPeopleLocationGet: %s\n" % e)

extern crate WebsocketApi;

pub fn main() {

    let mut context = WebsocketApi::Context::default();
    let result = client.appWsPeopleLocationGet(&context).wait();

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

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

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

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

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

        try {
            WifiAddress result = apiInstance.wifiAddressGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiAddressGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.WifiApi;

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

        try {
            WifiAddress result = apiInstance.wifiAddressGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiAddressGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the IP and MAC address of the WiFi interface
[apiInstance wifiAddressGetWithCompletionHandler: 
              ^(WifiAddress output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the IP and MAC address of the WiFi interface
                WifiAddress result = apiInstance.wifiAddressGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiAddressGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();

eval {
    my $result = $api_instance->wifiAddressGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiAddressGet: $@\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.WifiApi()

try:
    # Queries the IP and MAC address of the WiFi interface
    api_response = api_instance.wifi_address_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WifiApi->wifiAddressGet: %s\n" % e)

extern crate WifiApi;

pub fn main() {

    let mut context = WifiApi::Context::default();
    let result = client.wifiAddressGet(&context).wait();

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

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

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

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

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

        try {
            WifiInfo result = apiInstance.wifiGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.WifiApi;

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

        try {
            WifiInfo result = apiInstance.wifiGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiGet");
            e.printStackTrace();
        }
    }
}

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

// Query the current connection
[apiInstance wifiGetWithCompletionHandler: 
              ^(WifiInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Query the current connection
                WifiInfo result = apiInstance.wifiGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();

eval {
    my $result = $api_instance->wifiGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiGet: $@\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.WifiApi()

try:
    # Query the current connection
    api_response = api_instance.wifi_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WifiApi->wifiGet: %s\n" % e)

extern crate WifiApi;

pub fn main() {

    let mut context = WifiApi::Context::default();
    let result = client.wifiGet(&context).wait();

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

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

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

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

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

        try {
            Hostname result = apiInstance.wifiHostnameGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiHostnameGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.WifiApi;

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

        try {
            Hostname result = apiInstance.wifiHostnameGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WifiApi#wifiHostnameGet");
            e.printStackTrace();
        }
    }
}

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

// Queries the hostname of the device.
[apiInstance wifiHostnameGetWithCompletionHandler: 
              ^(Hostname output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries the hostname of the device.
                Hostname result = apiInstance.wifiHostnameGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiHostnameGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();

eval {
    my $result = $api_instance->wifiHostnameGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiHostnameGet: $@\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.WifiApi()

try:
    # Queries the hostname of the device.
    api_response = api_instance.wifi_hostname_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WifiApi->wifiHostnameGet: %s\n" % e)

extern crate WifiApi;

pub fn main() {

    let mut context = WifiApi::Context::default();
    let result = client.wifiHostnameGet(&context).wait();

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

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

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

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

        // Create an instance of the API class
        WifiApi apiInstance = new WifiApi();
        String hostName = hostName_example; // String | The new hostname of the device

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String hostName = new String(); // String | The new hostname of the device

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

import org.openapitools.client.api.WifiApi;

public class WifiApiExample {
    public static void main(String[] args) {
        WifiApi apiInstance = new WifiApi();
        String hostName = hostName_example; // String | The new hostname of the device

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

// Create an instance of the API class
WifiApi *apiInstance = [[WifiApi alloc] init];
String *hostName = hostName_example; // The new hostname of the device (default to null)

// Sets the hostname of the device.
[apiInstance wifiHostnameHostNamePutWith:hostName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.WifiApi()
var hostName = hostName_example; // {String} The new hostname of the device

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

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

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

            // Create an instance of the API class
            var apiInstance = new WifiApi();
            var hostName = hostName_example;  // String | The new hostname of the device (default to null)

            try {
                // Sets the hostname of the device.
                apiInstance.wifiHostnameHostNamePut(hostName);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiHostnameHostNamePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();
$hostName = hostName_example; // String | The new hostname of the device

try {
    $api_instance->wifiHostnameHostNamePut($hostName);
} catch (Exception $e) {
    echo 'Exception when calling WifiApi->wifiHostnameHostNamePut: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();
my $hostName = hostName_example; # String | The new hostname of the device

eval {
    $api_instance->wifiHostnameHostNamePut(hostName => $hostName);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiHostnameHostNamePut: $@\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.WifiApi()
hostName = hostName_example # String | The new hostname of the device (default to null)

try:
    # Sets the hostname of the device.
    api_instance.wifi_hostname_host_name_put(hostName)
except ApiException as e:
    print("Exception when calling WifiApi->wifiHostnameHostNamePut: %s\n" % e)

extern crate WifiApi;

pub fn main() {
    let hostName = hostName_example; // String

    let mut context = WifiApi::Context::default();
    let result = client.wifiHostnameHostNamePut(hostName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        WifiApi apiInstance = new WifiApi();
        WifiConfig wifiConfig = ; // WifiConfig | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final WifiConfig wifiConfig = new WifiConfig(); // WifiConfig | 

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

import org.openapitools.client.api.WifiApi;

public class WifiApiExample {
    public static void main(String[] args) {
        WifiApi apiInstance = new WifiApi();
        WifiConfig wifiConfig = ; // WifiConfig | 

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

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

// Creates a WiFi connection according to the specified parameters.
[apiInstance wifiPostWith:wifiConfig
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

// Create an instance of the API class
var api = new EdgeSensorWeb.WifiApi()
var wifiConfig = ; // {WifiConfig} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new WifiApi();
            var wifiConfig = new WifiConfig(); // WifiConfig | 

            try {
                // Creates a WiFi connection according to the specified parameters.
                apiInstance.wifiPost(wifiConfig);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();
$wifiConfig = ; // WifiConfig | 

try {
    $api_instance->wifiPost($wifiConfig);
} catch (Exception $e) {
    echo 'Exception when calling WifiApi->wifiPost: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();
my $wifiConfig = WWW::OPenAPIClient::Object::WifiConfig->new(); # WifiConfig | 

eval {
    $api_instance->wifiPost(wifiConfig => $wifiConfig);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiPost: $@\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.WifiApi()
wifiConfig =  # WifiConfig | 

try:
    # Creates a WiFi connection according to the specified parameters.
    api_instance.wifi_post(wifiConfig)
except ApiException as e:
    print("Exception when calling WifiApi->wifiPost: %s\n" % e)

extern crate WifiApi;

pub fn main() {
    let wifiConfig = ; // WifiConfig

    let mut context = WifiApi::Context::default();
    let result = client.wifiPost(wifiConfig, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.WifiApi;

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

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

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

// Queries available WiFi networks. The response is an empty array in hotspot mode.
[apiInstance wifiScanGetWithCompletionHandler: 
              ^(array[WifiStation] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var EdgeSensorWeb = require('edge_sensor_web');

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

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

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

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

            try {
                // Queries available WiFi networks. The response is an empty array in hotspot mode.
                array[WifiStation] result = apiInstance.wifiScanGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WifiApi.wifiScanGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WifiApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WifiApi->new();

eval {
    my $result = $api_instance->wifiScanGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WifiApi->wifiScanGet: $@\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.WifiApi()

try:
    # Queries available WiFi networks. The response is an empty array in hotspot mode.
    api_response = api_instance.wifi_scan_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WifiApi->wifiScanGet: %s\n" % e)

extern crate WifiApi;

pub fn main() {

    let mut context = WifiApi::Context::default();
    let result = client.wifiScanGet(&context).wait();

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