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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

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

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

// Deletes the current show
[apiInstance deleteShowWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Deletes the current show
                apiInstance.deleteShow();
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.deleteShow: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Deletes the current show
    api_instance.delete_show()
except ApiException as e:
    print("Exception when calling CoreApi->deleteShow: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.deleteShow(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

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

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

// Exports a showfile
[apiInstance exportShowWithCompletionHandler: 
              ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Exports a showfile
                File result = apiInstance.exportShow();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.exportShow: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Exports a showfile
    api_response = api_instance.export_show()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->exportShow: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.exportShow(&context).wait();

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

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

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

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

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

        try {
            Version result = apiInstance.getAPIVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getAPIVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

        try {
            Version result = apiInstance.getAPIVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getAPIVersion");
            e.printStackTrace();
        }
    }
}

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

// Returns the server API version
[apiInstance getAPIVersionWithCompletionHandler: 
              ^(Version output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Returns the server API version
                Version result = apiInstance.getAPIVersion();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getAPIVersion: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Returns the server API version
    api_response = api_instance.get_api_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getAPIVersion: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.getAPIVersion(&context).wait();

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

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

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

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

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

        try {
            getCollections_200_response result = apiInstance.getCollections();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getCollections");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

        try {
            getCollections_200_response result = apiInstance.getCollections();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getCollections");
            e.printStackTrace();
        }
    }
}

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

// Returns all collections in the Media Library
[apiInstance getCollectionsWithCompletionHandler: 
              ^(getCollections_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Returns all collections in the Media Library
                getCollections_200_response result = apiInstance.getCollections();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getCollections: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Returns all collections in the Media Library
    api_response = api_instance.get_collections()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getCollections: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.getCollections(&context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        String contentUrl = file:///file.awx; // String | The URL of the file for which metadata is needed

        try {
            Metadata result = apiInstance.getMetadata(contentUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getMetadata");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String contentUrl = new String(); // String | The URL of the file for which metadata is needed

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        String contentUrl = file:///file.awx; // String | The URL of the file for which metadata is needed

        try {
            Metadata result = apiInstance.getMetadata(contentUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getMetadata");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
String *contentUrl = file:///file.awx; // The URL of the file for which metadata is needed (default to null)

// Requests metadata for the given content URL
[apiInstance getMetadataWith:contentUrl
              completionHandler: ^(Metadata output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var contentUrl = file:///file.awx; // {String} The URL of the file for which metadata is needed

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var contentUrl = file:///file.awx;  // String | The URL of the file for which metadata is needed (default to null)

            try {
                // Requests metadata for the given content URL
                Metadata result = apiInstance.getMetadata(contentUrl);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getMetadata: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$contentUrl = file:///file.awx; // String | The URL of the file for which metadata is needed

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $contentUrl = file:///file.awx; # String | The URL of the file for which metadata is needed

eval {
    my $result = $api_instance->getMetadata(contentUrl => $contentUrl);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CoreApi->getMetadata: $@\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.CoreApi()
contentUrl = file:///file.awx # String | The URL of the file for which metadata is needed (default to null)

try:
    # Requests metadata for the given content URL
    api_response = api_instance.get_metadata(contentUrl)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getMetadata: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let contentUrl = file:///file.awx; // String

    let mut context = CoreApi::Context::default();
    let result = client.getMetadata(contentUrl, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            Playback result = apiInstance.getPlayback(playerIndex, playbackName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlayback");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            Playback result = apiInstance.getPlayback(playerIndex, playbackName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlayback");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Returns the state of a given playback
[apiInstance getPlaybackWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(Playback output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Returns the state of a given playback
                Playback result = apiInstance.getPlayback(playerIndex, playbackName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getPlayback: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    my $result = $api_instance->getPlayback(playerIndex => $playerIndex, playbackName => $playbackName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CoreApi->getPlayback: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Returns the state of a given playback
    api_response = api_instance.get_playback(playerIndex, playbackName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getPlayback: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.getPlayback(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one

        try {
            Player result = apiInstance.getPlayer(playerIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one

        try {
            Player result = apiInstance.getPlayer(playerIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlayer");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)

// Returns state of the player engine
[apiInstance getPlayerWith:playerIndex
              completionHandler: ^(Player output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)

            try {
                // Returns state of the player engine
                Player result = apiInstance.getPlayer(playerIndex);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getPlayer: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one

eval {
    my $result = $api_instance->getPlayer(playerIndex => $playerIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CoreApi->getPlayer: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)

try:
    # Returns state of the player engine
    api_response = api_instance.get_player(playerIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getPlayer: %s\n" % e)

extern crate CoreApi;

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

    let mut context = CoreApi::Context::default();
    let result = client.getPlayer(playerIndex, &context).wait();

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

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

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

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

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

        try {
            getPlaylists_200_response result = apiInstance.getPlaylists();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlaylists");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

        try {
            getPlaylists_200_response result = apiInstance.getPlaylists();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getPlaylists");
            e.printStackTrace();
        }
    }
}

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

// Returns all playlists in the Media Library
[apiInstance getPlaylistsWithCompletionHandler: 
              ^(getPlaylists_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Returns all playlists in the Media Library
                getPlaylists_200_response result = apiInstance.getPlaylists();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getPlaylists: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Returns all playlists in the Media Library
    api_response = api_instance.get_playlists()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getPlaylists: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.getPlaylists(&context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        array[String] topic = players; // array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

        try {
            array[JSONPatch] result = apiInstance.getSSE(topic);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getSSE");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] topic = new array[String](); // array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        array[String] topic = players; // array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

        try {
            array[JSONPatch] result = apiInstance.getSSE(topic);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#getSSE");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
array[String] *topic = players; // Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat. (default to null)

// Creates an SSE stream for real-time events
[apiInstance getSSEWith:topic
              completionHandler: ^(array[JSONPatch] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var topic = players; // {array[String]} Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var topic = new array[String](); // array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat. (default to null)

            try {
                // Creates an SSE stream for real-time events
                array[JSONPatch] result = apiInstance.getSSE(topic);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getSSE: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$topic = players; // array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $topic = [players]; # array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat.

eval {
    my $result = $api_instance->getSSE(topic => $topic);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CoreApi->getSSE: $@\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.CoreApi()
topic = players # array[String] | Array of topics to include in the stream. If no topics are specified, the endpoint returns everything.
- players: Includes playback status information
- system: Includes system uptime that can be used as a connection heartbeat. (default to null)

try:
    # Creates an SSE stream for real-time events
    api_response = api_instance.get_sse(topic)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getSSE: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let topic = players; // array[String]

    let mut context = CoreApi::Context::default();
    let result = client.getSSE(topic, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

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

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

// Returns information about the device and it's firmware.
[apiInstance getSystemInformationWithCompletionHandler: 
              ^(System output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Returns information about the device and it's firmware.
                System result = apiInstance.getSystemInformation();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.getSystemInformation: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Returns information about the device and it's firmware.
    api_response = api_instance.get_system_information()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreApi->getSystemInformation: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.getSystemInformation(&context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        array[String] include = ; // array[String] | Properties to include
        Boolean force = true; // Boolean | Force import showfile regardless of showfile version
        File body = BINARY_DATA_HERE; // File | 

        try {
            apiInstance.importShow(include, force, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#importShow");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] include = new array[String](); // array[String] | Properties to include
final Boolean force = new Boolean(); // Boolean | Force import showfile regardless of showfile version
final File body = new File(); // File | 

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        array[String] include = ; // array[String] | Properties to include
        Boolean force = true; // Boolean | Force import showfile regardless of showfile version
        File body = BINARY_DATA_HERE; // File | 

        try {
            apiInstance.importShow(include, force, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#importShow");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
array[String] *include = ; // Properties to include (optional) (default to null)
Boolean *force = true; // Force import showfile regardless of showfile version (optional) (default to null)
File *body = BINARY_DATA_HERE; //  (optional)

// Imports a showfile
[apiInstance importShowWith:include
    force:force
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var opts = {
  'include': , // {array[String]} Properties to include
  'force': true, // {Boolean} Force import showfile regardless of showfile version
  'body': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var include = new array[String](); // array[String] | Properties to include (optional)  (default to null)
            var force = true;  // Boolean | Force import showfile regardless of showfile version (optional)  (default to null)
            var body = BINARY_DATA_HERE;  // File |  (optional) 

            try {
                // Imports a showfile
                apiInstance.importShow(include, force, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.importShow: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$include = ; // array[String] | Properties to include
$force = true; // Boolean | Force import showfile regardless of showfile version
$body = BINARY_DATA_HERE; // File | 

try {
    $api_instance->importShow($include, $force, $body);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->importShow: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $include = []; # array[String] | Properties to include
my $force = true; # Boolean | Force import showfile regardless of showfile version
my $body = WWW::OPenAPIClient::Object::File->new(); # File | 

eval {
    $api_instance->importShow(include => $include, force => $force, body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->importShow: $@\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.CoreApi()
include =  # array[String] | Properties to include (optional) (default to null)
force = true # Boolean | Force import showfile regardless of showfile version (optional) (default to null)
body = BINARY_DATA_HERE # File |  (optional)

try:
    # Imports a showfile
    api_instance.import_show(include=include, force=force, body=body)
except ApiException as e:
    print("Exception when calling CoreApi->importShow: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let include = ; // array[String]
    let force = true; // Boolean
    let body = BINARY_DATA_HERE; // File

    let mut context = CoreApi::Context::default();
    let result = client.importShow(include, force, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.mute(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#mute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.mute(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#mute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Mutes the playback
[apiInstance muteWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Mutes the playback
                apiInstance.mute(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.mute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->mute($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->mute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->mute(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->mute: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Mutes the playback
    api_instance.mute(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->mute: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.mute(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.next(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#next");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.next(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#next");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Advances to the next item in the playlist
[apiInstance nextWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Advances to the next item in the playlist
                apiInstance.next(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.next: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->next($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->next: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->next(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->next: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Advances to the next item in the playlist
    api_instance.next(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->next: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.next(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.pause(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#pause");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.pause(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#pause");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Sets the playback state to `pause`.
[apiInstance pauseWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Sets the playback state to `pause`.
                apiInstance.pause(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.pause: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->pause($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->pause: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->pause(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->pause: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Sets the playback state to `pause`.
    api_instance.pause(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->pause: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.pause(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.play(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#play");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.play(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#play");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Sets the playback state to `play`.
[apiInstance playWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Sets the playback state to `play`.
                apiInstance.play(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.play: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->play($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->play: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->play(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->play: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Sets the playback state to `play`.
    api_instance.play(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->play: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.play(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.previous(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#previous");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.previous(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#previous");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Advances to the previous item in the playlist
[apiInstance previousWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Advances to the previous item in the playlist
                apiInstance.previous(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.previous: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->previous($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->previous: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->previous(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->previous: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Advances to the previous item in the playlist
    api_instance.previous(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->previous: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.previous(playerIndex, playbackName, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

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

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

// Reboots the device
[apiInstance rebootWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Reboots the device
                apiInstance.reboot();
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.reboot: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Reboots the device
    api_instance.reboot()
except ApiException as e:
    print("Exception when calling CoreApi->reboot: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.reboot(&context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        BigDecimal position = 0.0; // BigDecimal | The seek position in seconds from inpoint to endpoint.
        BigDecimal mediaPosition = 0.0; // BigDecimal | The seek position in seconds from start of media.
        BigDecimal normalizedPosition = 0.0; // BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0)

        try {
            apiInstance.seek(playerIndex, playbackName, position, mediaPosition, normalizedPosition);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#seek");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`
final BigDecimal position = new BigDecimal(); // BigDecimal | The seek position in seconds from inpoint to endpoint.
final BigDecimal mediaPosition = new BigDecimal(); // BigDecimal | The seek position in seconds from start of media.
final BigDecimal normalizedPosition = new BigDecimal(); // BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0)

try {
    final result = await api_instance.seek(playerIndex, playbackName, position, mediaPosition, normalizedPosition);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->seek: $e\n');
}

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        BigDecimal position = 0.0; // BigDecimal | The seek position in seconds from inpoint to endpoint.
        BigDecimal mediaPosition = 0.0; // BigDecimal | The seek position in seconds from start of media.
        BigDecimal normalizedPosition = 0.0; // BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0)

        try {
            apiInstance.seek(playerIndex, playbackName, position, mediaPosition, normalizedPosition);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#seek");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)
BigDecimal *position = 0.0; // The seek position in seconds from inpoint to endpoint. (optional) (default to null)
BigDecimal *mediaPosition = 0.0; // The seek position in seconds from start of media. (optional) (default to null)
BigDecimal *normalizedPosition = 0.0; // The normalized seek position between inpoint (0.0) and outpoint (1.0) (optional) (default to null)

// Seeks inside the current media
[apiInstance seekWith:playerIndex
    playbackName:playbackName
    position:position
    mediaPosition:mediaPosition
    normalizedPosition:normalizedPosition
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`
var opts = {
  'position': 0.0, // {BigDecimal} The seek position in seconds from inpoint to endpoint.
  'mediaPosition': 0.0, // {BigDecimal} The seek position in seconds from start of media.
  'normalizedPosition': 0.0 // {BigDecimal} The normalized seek position between inpoint (0.0) and outpoint (1.0)
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)
            var position = 0.0;  // BigDecimal | The seek position in seconds from inpoint to endpoint. (optional)  (default to null)
            var mediaPosition = 0.0;  // BigDecimal | The seek position in seconds from start of media. (optional)  (default to null)
            var normalizedPosition = 0.0;  // BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0) (optional)  (default to null)

            try {
                // Seeks inside the current media
                apiInstance.seek(playerIndex, playbackName, position, mediaPosition, normalizedPosition);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.seek: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`
$position = 0.0; // BigDecimal | The seek position in seconds from inpoint to endpoint.
$mediaPosition = 0.0; // BigDecimal | The seek position in seconds from start of media.
$normalizedPosition = 0.0; // BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0)

try {
    $api_instance->seek($playerIndex, $playbackName, $position, $mediaPosition, $normalizedPosition);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->seek: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`
my $position = 0.0; # BigDecimal | The seek position in seconds from inpoint to endpoint.
my $mediaPosition = 0.0; # BigDecimal | The seek position in seconds from start of media.
my $normalizedPosition = 0.0; # BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0)

eval {
    $api_instance->seek(playerIndex => $playerIndex, playbackName => $playbackName, position => $position, mediaPosition => $mediaPosition, normalizedPosition => $normalizedPosition);
};
if ($@) {
    warn "Exception when calling CoreApi->seek: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)
position = 0.0 # BigDecimal | The seek position in seconds from inpoint to endpoint. (optional) (default to null)
mediaPosition = 0.0 # BigDecimal | The seek position in seconds from start of media. (optional) (default to null)
normalizedPosition = 0.0 # BigDecimal | The normalized seek position between inpoint (0.0) and outpoint (1.0) (optional) (default to null)

try:
    # Seeks inside the current media
    api_instance.seek(playerIndex, playbackName, position=position, mediaPosition=mediaPosition, normalizedPosition=normalizedPosition)
except ApiException as e:
    print("Exception when calling CoreApi->seek: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String
    let position = 0.0; // BigDecimal
    let mediaPosition = 0.0; // BigDecimal
    let normalizedPosition = 0.0; // BigDecimal

    let mut context = CoreApi::Context::default();
    let result = client.seek(playerIndex, playbackName, position, mediaPosition, normalizedPosition, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        MediaIdentifier mediaIdentifier = ; // MediaIdentifier | 

        try {
            apiInstance.setPlaybackMedia(playerIndex, playbackName, mediaIdentifier);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#setPlaybackMedia");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`
final MediaIdentifier mediaIdentifier = new MediaIdentifier(); // MediaIdentifier | 

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        MediaIdentifier mediaIdentifier = ; // MediaIdentifier | 

        try {
            apiInstance.setPlaybackMedia(playerIndex, playbackName, mediaIdentifier);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#setPlaybackMedia");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)
MediaIdentifier *mediaIdentifier = ; //  (optional)

// Sets the given media on the playback, without changing the playback state.
[apiInstance setPlaybackMediaWith:playerIndex
    playbackName:playbackName
    mediaIdentifier:mediaIdentifier
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`
var opts = {
  'mediaIdentifier':  // {MediaIdentifier} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)
            var mediaIdentifier = new MediaIdentifier(); // MediaIdentifier |  (optional) 

            try {
                // Sets the given media on the playback, without changing the playback state.
                apiInstance.setPlaybackMedia(playerIndex, playbackName, mediaIdentifier);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.setPlaybackMedia: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`
$mediaIdentifier = ; // MediaIdentifier | 

try {
    $api_instance->setPlaybackMedia($playerIndex, $playbackName, $mediaIdentifier);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->setPlaybackMedia: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`
my $mediaIdentifier = WWW::OPenAPIClient::Object::MediaIdentifier->new(); # MediaIdentifier | 

eval {
    $api_instance->setPlaybackMedia(playerIndex => $playerIndex, playbackName => $playbackName, mediaIdentifier => $mediaIdentifier);
};
if ($@) {
    warn "Exception when calling CoreApi->setPlaybackMedia: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)
mediaIdentifier =  # MediaIdentifier |  (optional)

try:
    # Sets the given media on the playback, without changing the playback state.
    api_instance.set_playback_media(playerIndex, playbackName, mediaIdentifier=mediaIdentifier)
except ApiException as e:
    print("Exception when calling CoreApi->setPlaybackMedia: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String
    let mediaIdentifier = ; // MediaIdentifier

    let mut context = CoreApi::Context::default();
    let result = client.setPlaybackMedia(playerIndex, playbackName, mediaIdentifier, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        Double volume = 0.0; // Double | New volume for the playback. Value is in decibels.

        try {
            apiInstance.setVolume(playerIndex, playbackName, volume);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#setVolume");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`
final Double volume = new Double(); // Double | New volume for the playback. Value is in decibels.

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`
        Double volume = 0.0; // Double | New volume for the playback. Value is in decibels.

        try {
            apiInstance.setVolume(playerIndex, playbackName, volume);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#setVolume");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)
Double *volume = 0.0; // New volume for the playback. Value is in decibels. (default to null)

// Sets the playback volume
[apiInstance setVolumeWith:playerIndex
    playbackName:playbackName
    volume:volume
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`
var volume = 0.0; // {Double} New volume for the playback. Value is in decibels.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setVolume(playerIndex, playbackName, volume, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)
            var volume = 0.0;  // Double | New volume for the playback. Value is in decibels. (default to null)

            try {
                // Sets the playback volume
                apiInstance.setVolume(playerIndex, playbackName, volume);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.setVolume: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`
$volume = 0.0; // Double | New volume for the playback. Value is in decibels.

try {
    $api_instance->setVolume($playerIndex, $playbackName, $volume);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->setVolume: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`
my $volume = 0.0; # Double | New volume for the playback. Value is in decibels.

eval {
    $api_instance->setVolume(playerIndex => $playerIndex, playbackName => $playbackName, volume => $volume);
};
if ($@) {
    warn "Exception when calling CoreApi->setVolume: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)
volume = 0.0 # Double | New volume for the playback. Value is in decibels. (default to null)

try:
    # Sets the playback volume
    api_instance.set_volume(playerIndex, playbackName, volume)
except ApiException as e:
    print("Exception when calling CoreApi->setVolume: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String
    let volume = 0.0; // Double

    let mut context = CoreApi::Context::default();
    let result = client.setVolume(playerIndex, playbackName, volume, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CoreApi;

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

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

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

// Turns off the device
[apiInstance shutdownWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

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

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

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

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

            try {
                // Turns off the device
                apiInstance.shutdown();
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.shutdown: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Turns off the device
    api_instance.shutdown()
except ApiException as e:
    print("Exception when calling CoreApi->shutdown: %s\n" % e)

extern crate CoreApi;

pub fn main() {

    let mut context = CoreApi::Context::default();
    let result = client.shutdown(&context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.stop(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#stop");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.stop(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#stop");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Sets the playback state to `stop`.
[apiInstance stopWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Sets the playback state to `stop`.
                apiInstance.stop(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.stop: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->stop($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->stop: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->stop(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->stop: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Sets the playback state to `stop`.
    api_instance.stop(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->stop: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.stop(playerIndex, playbackName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        Take take = ; // Take | 

        try {
            apiInstance.take(playerIndex, take);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#take");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final Take take = new Take(); // Take | 

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        Take take = ; // Take | 

        try {
            apiInstance.take(playerIndex, take);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#take");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
Take *take = ; //  (optional)

// Triggers a take from Preview to Program
[apiInstance takeWith:playerIndex
    take:take
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var opts = {
  'take':  // {Take} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var take = new Take(); // Take |  (optional) 

            try {
                // Triggers a take from Preview to Program
                apiInstance.take(playerIndex, take);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.take: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$take = ; // Take | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $take = WWW::OPenAPIClient::Object::Take->new(); # Take | 

eval {
    $api_instance->take(playerIndex => $playerIndex, take => $take);
};
if ($@) {
    warn "Exception when calling CoreApi->take: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
take =  # Take |  (optional)

try:
    # Triggers a take from Preview to Program
    api_instance.take(playerIndex, take=take)
except ApiException as e:
    print("Exception when calling CoreApi->take: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let take = ; // Take

    let mut context = CoreApi::Context::default();
    let result = client.take(playerIndex, take, &context).wait();

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

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

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

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

        // Create an instance of the API class
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.unmute(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#unmute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer playerIndex = new Integer(); // Integer | The player index starting from one
final String playbackName = new String(); // String | The playback name `program` or `preview`

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

import org.openapitools.client.api.CoreApi;

public class CoreApiExample {
    public static void main(String[] args) {
        CoreApi apiInstance = new CoreApi();
        Integer playerIndex = 56; // Integer | The player index starting from one
        String playbackName = playbackName_example; // String | The playback name `program` or `preview`

        try {
            apiInstance.unmute(playerIndex, playbackName);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#unmute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CoreApi *apiInstance = [[CoreApi alloc] init];
Integer *playerIndex = 56; // The player index starting from one (default to null)
String *playbackName = playbackName_example; // The playback name `program` or `preview` (default to null)

// Unmutes the playback
[apiInstance unmuteWith:playerIndex
    playbackName:playbackName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnalogWayCoreApi = require('analog_way_core_api');

// Create an instance of the API class
var api = new AnalogWayCoreApi.CoreApi()
var playerIndex = 56; // {Integer} The player index starting from one
var playbackName = playbackName_example; // {String} The playback name `program` or `preview`

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

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

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

            // Create an instance of the API class
            var apiInstance = new CoreApi();
            var playerIndex = 56;  // Integer | The player index starting from one (default to null)
            var playbackName = playbackName_example;  // String | The playback name `program` or `preview` (default to null)

            try {
                // Unmutes the playback
                apiInstance.unmute(playerIndex, playbackName);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreApi.unmute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreApi();
$playerIndex = 56; // Integer | The player index starting from one
$playbackName = playbackName_example; // String | The playback name `program` or `preview`

try {
    $api_instance->unmute($playerIndex, $playbackName);
} catch (Exception $e) {
    echo 'Exception when calling CoreApi->unmute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreApi->new();
my $playerIndex = 56; # Integer | The player index starting from one
my $playbackName = playbackName_example; # String | The playback name `program` or `preview`

eval {
    $api_instance->unmute(playerIndex => $playerIndex, playbackName => $playbackName);
};
if ($@) {
    warn "Exception when calling CoreApi->unmute: $@\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.CoreApi()
playerIndex = 56 # Integer | The player index starting from one (default to null)
playbackName = playbackName_example # String | The playback name `program` or `preview` (default to null)

try:
    # Unmutes the playback
    api_instance.unmute(playerIndex, playbackName)
except ApiException as e:
    print("Exception when calling CoreApi->unmute: %s\n" % e)

extern crate CoreApi;

pub fn main() {
    let playerIndex = 56; // Integer
    let playbackName = playbackName_example; // String

    let mut context = CoreApi::Context::default();
    let result = client.unmute(playerIndex, playbackName, &context).wait();

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