Animation Graph Microservice

Default

asyncAppDocsEndpointAsyncapiDocsGet

Async App Docs Endpoint

/asyncapi/docs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/asyncapi/docs?app_name=appName_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appName = appName_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DefaultApi;

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

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



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

//  Async App Docs Endpoint
[apiInstance asyncAppDocsEndpointAsyncapiDocsGetWith:appName
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var appName = appName_example; // {String} 

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

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

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

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

            try {
                //  Async App Docs Endpoint
                oas_any_type_not_mapped result = apiInstance.asyncAppDocsEndpointAsyncapiDocsGet(appName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.asyncAppDocsEndpointAsyncapiDocsGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appName = appName_example # String |  (default to null)

try:
    #  Async App Docs Endpoint
    api_response = api_instance.async_app_docs_endpoint_asyncapi_docs_get(appName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->asyncAppDocsEndpointAsyncapiDocsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let appName = appName_example; // String

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

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

Scopes

Parameters

Query parameters

Name	Description
app_name*	String Required

Responses

Schema

Schema

asyncAppSchemaEndpointAsyncapiSchemaGet

Async App Schema Endpoint

/asyncapi/schema

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/asyncapi/schema?app_name=appName_example"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appName = appName_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DefaultApi;

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

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



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

//  Async App Schema Endpoint
[apiInstance asyncAppSchemaEndpointAsyncapiSchemaGetWith:appName
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var appName = appName_example; // {String} 

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

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

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

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

            try {
                //  Async App Schema Endpoint
                oas_any_type_not_mapped result = apiInstance.asyncAppSchemaEndpointAsyncapiSchemaGet(appName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.asyncAppSchemaEndpointAsyncapiSchemaGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appName = appName_example # String |  (default to null)

try:
    #  Async App Schema Endpoint
    api_response = api_instance.async_app_schema_endpoint_asyncapi_schema_get(appName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->asyncAppSchemaEndpointAsyncapiSchemaGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let appName = appName_example; // String

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

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

Scopes

Parameters

Query parameters

Name	Description
app_name*	String Required

Responses

Schema

Schema

deleteStreamsStreamIdStreamsStreamIdDelete

Delete Streams Stream Id

/streams/{stream_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 

        try {
            'String' result = apiInstance.deleteStreamsStreamIdStreamsStreamIdDelete(streamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteStreamsStreamIdStreamsStreamIdDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            'String' result = apiInstance.deleteStreamsStreamIdStreamsStreamIdDelete(streamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteStreamsStreamIdStreamsStreamIdDelete");
            e.printStackTrace();
        }
    }
}



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

// Delete Streams Stream Id
[apiInstance deleteStreamsStreamIdStreamsStreamIdDeleteWith:streamId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 

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

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

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

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

            try {
                // Delete Streams Stream Id
                'String' result = apiInstance.deleteStreamsStreamIdStreamsStreamIdDelete(streamId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteStreamsStreamIdStreamsStreamIdDelete: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)

try:
    # Delete Streams Stream Id
    api_response = api_instance.delete_streams_stream_id_streams_stream_id_delete(streamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteStreamsStreamIdStreamsStreamIdDelete: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required

Responses

Schema

Schema

getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet

Get Animation Graph Variables

/animation_graphs/avatar/variables

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/animation_graphs/avatar/variables"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Get Animation Graph Variables
[apiInstance getAnimationGraphVariablesAnimationGraphsAvatarVariablesGetWithCompletionHandler: 
              ^(array[oas_any_type_not_mapped] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Get Animation Graph Variables
                array[oas_any_type_not_mapped] result = apiInstance.getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get Animation Graph Variables
    api_response = api_instance.get_animation_graph_variables_animation_graphs_avatar_variables_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

getAnimationGraphsAnimationGraphsGet

Get Animation Graphs

/animation_graphs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/animation_graphs"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Get Animation Graphs
[apiInstance getAnimationGraphsAnimationGraphsGetWithCompletionHandler: 
              ^(array[oas_any_type_not_mapped] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Get Animation Graphs
                array[oas_any_type_not_mapped] result = apiInstance.getAnimationGraphsAnimationGraphsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getAnimationGraphsAnimationGraphsGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get Animation Graphs
    api_response = api_instance.get_animation_graphs_animation_graphs_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAnimationGraphsAnimationGraphsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

getStreamsStreamsGet

Get Streams

/streams

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/streams"

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

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

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

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

        try {
            set[oas_any_type_not_mapped] result = apiInstance.getStreamsStreamsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getStreamsStreamsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

        try {
            set[oas_any_type_not_mapped] result = apiInstance.getStreamsStreamsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getStreamsStreamsGet");
            e.printStackTrace();
        }
    }
}



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

// Get Streams
[apiInstance getStreamsStreamsGetWithCompletionHandler: 
              ^(set[oas_any_type_not_mapped] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Get Streams
                set[oas_any_type_not_mapped] result = apiInstance.getStreamsStreamsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getStreamsStreamsGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get Streams
    api_response = api_instance.get_streams_streams_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getStreamsStreamsGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

livenessLivenessGet

Liveness

/liveness

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/liveness"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Liveness
[apiInstance livenessLivenessGetWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Liveness
                'String' result = apiInstance.livenessLivenessGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.livenessLivenessGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Liveness
    api_response = api_instance.liveness_liveness_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->livenessLivenessGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

postSdrAddStreamSdrAddStreamPost

Post Sdr Add Stream

/sdr/add_stream

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/sdr/add_stream" \
 -d '{
  "event" : {
    "camera_id" : "camera_id"
  }
}'

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

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

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

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

        try {
            'String' result = apiInstance.postSdrAddStreamSdrAddStreamPost(postSdrStreamsBodyModel);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSdrAddStreamSdrAddStreamPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PostSdrStreamsBodyModel postSdrStreamsBodyModel = new PostSdrStreamsBodyModel(); // PostSdrStreamsBodyModel | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            'String' result = apiInstance.postSdrAddStreamSdrAddStreamPost(postSdrStreamsBodyModel);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSdrAddStreamSdrAddStreamPost");
            e.printStackTrace();
        }
    }
}



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

// Post Sdr Add Stream
[apiInstance postSdrAddStreamSdrAddStreamPostWith:postSdrStreamsBodyModel
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var postSdrStreamsBodyModel = ; // {PostSdrStreamsBodyModel} 

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

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

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

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

            try {
                // Post Sdr Add Stream
                'String' result = apiInstance.postSdrAddStreamSdrAddStreamPost(postSdrStreamsBodyModel);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postSdrAddStreamSdrAddStreamPost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Post Sdr Add Stream
    api_response = api_instance.post_sdr_add_stream_sdr_add_stream_post(postSdrStreamsBodyModel)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postSdrAddStreamSdrAddStreamPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let postSdrStreamsBodyModel = ; // PostSdrStreamsBodyModel

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

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

Scopes

Parameters

Body parameters

Name	Description
postSdrStreamsBodyModel *

Responses

Schema

Schema

postSdrRemoveStreamSdrRemoveStreamPost

Post Sdr Remove Stream

/sdr/remove_stream

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/sdr/remove_stream" \
 -d '{
  "event" : {
    "camera_id" : "camera_id"
  }
}'

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

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

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

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

        try {
            'String' result = apiInstance.postSdrRemoveStreamSdrRemoveStreamPost(deleteSdrStreamsBodyModel);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSdrRemoveStreamSdrRemoveStreamPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DeleteSdrStreamsBodyModel deleteSdrStreamsBodyModel = new DeleteSdrStreamsBodyModel(); // DeleteSdrStreamsBodyModel | 

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            'String' result = apiInstance.postSdrRemoveStreamSdrRemoveStreamPost(deleteSdrStreamsBodyModel);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSdrRemoveStreamSdrRemoveStreamPost");
            e.printStackTrace();
        }
    }
}



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

// Post Sdr Remove Stream
[apiInstance postSdrRemoveStreamSdrRemoveStreamPostWith:deleteSdrStreamsBodyModel
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var deleteSdrStreamsBodyModel = ; // {DeleteSdrStreamsBodyModel} 

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

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

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

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

            try {
                // Post Sdr Remove Stream
                'String' result = apiInstance.postSdrRemoveStreamSdrRemoveStreamPost(deleteSdrStreamsBodyModel);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postSdrRemoveStreamSdrRemoveStreamPost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Post Sdr Remove Stream
    api_response = api_instance.post_sdr_remove_stream_sdr_remove_stream_post(deleteSdrStreamsBodyModel)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postSdrRemoveStreamSdrRemoveStreamPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let deleteSdrStreamsBodyModel = ; // DeleteSdrStreamsBodyModel

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

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

Scopes

Parameters

Body parameters

Name	Description
deleteSdrStreamsBodyModel *

Responses

Schema

Schema

postStreamsStreamIdStreamsStreamIdPost

Post Streams Stream Id

/streams/{stream_id}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 

        try {
            'String' result = apiInstance.postStreamsStreamIdStreamsStreamIdPost(streamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postStreamsStreamIdStreamsStreamIdPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DefaultApi;

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

        try {
            'String' result = apiInstance.postStreamsStreamIdStreamsStreamIdPost(streamId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postStreamsStreamIdStreamsStreamIdPost");
            e.printStackTrace();
        }
    }
}



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

// Post Streams Stream Id
[apiInstance postStreamsStreamIdStreamsStreamIdPostWith:streamId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 

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

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

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

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

            try {
                // Post Streams Stream Id
                'String' result = apiInstance.postStreamsStreamIdStreamsStreamIdPost(streamId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postStreamsStreamIdStreamsStreamIdPost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)

try:
    # Post Streams Stream Id
    api_response = api_instance.post_streams_stream_id_streams_stream_id_post(streamId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postStreamsStreamIdStreamsStreamIdPost: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required

Responses

Schema

Schema

readinessReadinessGet

Readiness

/readiness

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/readiness"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Readiness
[apiInstance readinessReadinessGetWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Readiness
                'String' result = apiInstance.readinessReadinessGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.readinessReadinessGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Readiness
    api_response = api_instance.readiness_readiness_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->readinessReadinessGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

statusHealthGet

Health probe

Returns the current status of the service.

/health

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/health"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Health probe
[apiInstance statusHealthGetWithCompletionHandler: 
              ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Health probe
                oas_any_type_not_mapped result = apiInstance.statusHealthGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.statusHealthGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Health probe
    api_response = api_instance.status_health_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->statusHealthGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

statusReadyGet

Readiness probe

Returns the current status of the service.

/ready

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/ready"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Readiness probe
[apiInstance statusReadyGetWithCompletionHandler: 
              ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Readiness probe
                oas_any_type_not_mapped result = apiInstance.statusReadyGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.statusReadyGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Readiness probe
    api_response = api_instance.status_ready_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->statusReadyGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

statusStartupGet

Startup probe

Returns the current status of the service.

/startup

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/startup"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Startup probe
[apiInstance statusStartupGetWithCompletionHandler: 
              ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Startup probe
                oas_any_type_not_mapped result = apiInstance.statusStartupGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.statusStartupGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Startup probe
    api_response = api_instance.status_startup_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->statusStartupGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

statusStatusGet

Returns the current status of the service

Returns the current status of the service.

/status

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/status"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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



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

// Returns the current status of the service
[apiInstance statusStatusGetWithCompletionHandler: 
              ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

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

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

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

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

            try {
                // Returns the current status of the service
                oas_any_type_not_mapped result = apiInstance.statusStatusGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.statusStatusGet: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Returns the current status of the service
    api_response = api_instance.status_status_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->statusStatusGet: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut

Update Variable By Stream Id And Value Callable

/streams/{stream_id}/animation_graphs/avatar/variables/facial_gesture_state/{value}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}/animation_graphs/avatar/variables/facial_gesture_state/{value}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String streamId = new String(); // String | 
final String value = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *streamId = streamId_example; //  (default to null)
String *value = value_example; //  (default to null)

// Update Variable By Stream Id And Value Callable
[apiInstance updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePutWith:streamId
    value:value
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 
var value = value_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var streamId = streamId_example;  // String |  (default to null)
            var value = value_example;  // String |  (default to null)

            try {
                // Update Variable By Stream Id And Value Callable
                'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut(streamId, value);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$streamId = streamId_example; // String | 
$value = value_example; // String | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)
value = value_example # String |  (default to null)

try:
    # Update Variable By Stream Id And Value Callable
    api_response = api_instance.update_variable_by_stream_id_and_value_callable_streams_stream_id_animation_graphs_avatar_variables_facial_gesture_state_value_put(streamId, value)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String
    let value = value_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut(streamId, value, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required
value*	String Required

Responses

Schema

Schema

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut

Update Variable By Stream Id And Value Callable

/streams/{stream_id}/animation_graphs/avatar/variables/gesture_state/{value}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}/animation_graphs/avatar/variables/gesture_state/{value}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String streamId = new String(); // String | 
final String value = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *streamId = streamId_example; //  (default to null)
String *value = value_example; //  (default to null)

// Update Variable By Stream Id And Value Callable
[apiInstance updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePutWith:streamId
    value:value
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 
var value = value_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var streamId = streamId_example;  // String |  (default to null)
            var value = value_example;  // String |  (default to null)

            try {
                // Update Variable By Stream Id And Value Callable
                'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut(streamId, value);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$streamId = streamId_example; // String | 
$value = value_example; // String | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)
value = value_example # String |  (default to null)

try:
    # Update Variable By Stream Id And Value Callable
    api_response = api_instance.update_variable_by_stream_id_and_value_callable_streams_stream_id_animation_graphs_avatar_variables_gesture_state_value_put(streamId, value)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String
    let value = value_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut(streamId, value, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required
value*	String Required

Responses

Schema

Schema

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut

Update Variable By Stream Id And Value Callable

/streams/{stream_id}/animation_graphs/avatar/variables/position_state/{value}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}/animation_graphs/avatar/variables/position_state/{value}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String streamId = new String(); // String | 
final String value = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *streamId = streamId_example; //  (default to null)
String *value = value_example; //  (default to null)

// Update Variable By Stream Id And Value Callable
[apiInstance updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePutWith:streamId
    value:value
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 
var value = value_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var streamId = streamId_example;  // String |  (default to null)
            var value = value_example;  // String |  (default to null)

            try {
                // Update Variable By Stream Id And Value Callable
                'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut(streamId, value);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$streamId = streamId_example; // String | 
$value = value_example; // String | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)
value = value_example # String |  (default to null)

try:
    # Update Variable By Stream Id And Value Callable
    api_response = api_instance.update_variable_by_stream_id_and_value_callable_streams_stream_id_animation_graphs_avatar_variables_position_state_value_put(streamId, value)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String
    let value = value_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut(streamId, value, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required
value*	String Required

Responses

Schema

Schema

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut

Update Variable By Stream Id And Value Callable

/streams/{stream_id}/animation_graphs/avatar/variables/posture_state/{value}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost/streams/{stream_id}/animation_graphs/avatar/variables/posture_state/{value}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String streamId = new String(); // String | 
final String value = new String(); // String | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String streamId = streamId_example; // String | 
        String value = value_example; // String | 

        try {
            'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut(streamId, value);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *streamId = streamId_example; //  (default to null)
String *value = value_example; //  (default to null)

// Update Variable By Stream Id And Value Callable
[apiInstance updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePutWith:streamId
    value:value
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AnimationGraphMicroservice = require('animation_graph_microservice');

// Create an instance of the API class
var api = new AnimationGraphMicroservice.DefaultApi()
var streamId = streamId_example; // {String} 
var value = value_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var streamId = streamId_example;  // String |  (default to null)
            var value = value_example;  // String |  (default to null)

            try {
                // Update Variable By Stream Id And Value Callable
                'String' result = apiInstance.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut(streamId, value);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$streamId = streamId_example; // String | 
$value = value_example; // String | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
streamId = streamId_example # String |  (default to null)
value = value_example # String |  (default to null)

try:
    # Update Variable By Stream Id And Value Callable
    api_response = api_instance.update_variable_by_stream_id_and_value_callable_streams_stream_id_animation_graphs_avatar_variables_posture_state_value_put(streamId, value)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let streamId = streamId_example; // String
    let value = value_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut(streamId, value, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
stream_id*	String Required
value*	String Required

Responses

Schema

Schema

Animation Graph Microservice

API and SDK Documentation

Default

asyncAppDocsEndpointAsyncapiDocsGet

Usage and SDK Samples

Scopes

Parameters

Responses

asyncAppSchemaEndpointAsyncapiSchemaGet

Usage and SDK Samples

Scopes

Parameters

Responses

deleteStreamsStreamIdStreamsStreamIdDelete

Usage and SDK Samples

Scopes

Parameters

Responses

getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet

Usage and SDK Samples

Scopes

Parameters

Responses

getAnimationGraphsAnimationGraphsGet

Usage and SDK Samples

Scopes

Parameters

Responses

getStreamsStreamsGet

Usage and SDK Samples

Scopes

Parameters

Responses

livenessLivenessGet

Usage and SDK Samples

Scopes

Parameters

Responses

postSdrAddStreamSdrAddStreamPost

Usage and SDK Samples

Scopes

Parameters

Responses

postSdrRemoveStreamSdrRemoveStreamPost

Usage and SDK Samples

Scopes

Parameters

Responses

postStreamsStreamIdStreamsStreamIdPost

Usage and SDK Samples

Scopes

Parameters

Responses

readinessReadinessGet

Usage and SDK Samples

Scopes

Parameters

Responses

statusHealthGet

Usage and SDK Samples

Scopes

Parameters

Responses

statusReadyGet

Usage and SDK Samples

Scopes

Parameters

Responses

statusStartupGet

Usage and SDK Samples

Scopes

Parameters

Responses

statusStatusGet

Usage and SDK Samples

Scopes

Parameters

Responses

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut

Usage and SDK Samples