动画图微服务

默认

asyncAppDocsEndpointAsyncapiDocsGet

异步应用文档端点

/asyncapi/docs

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

查询参数

名称	描述
app_name*	字符串必需

响应

架构

架构

asyncAppSchemaEndpointAsyncapiSchemaGet

异步应用架构端点

/asyncapi/schema

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

查询参数

名称	描述
app_name*	字符串必需

响应

架构

架构

deleteStreamsStreamIdStreamsStreamIdDelete

删除流 Stream Id

/streams/{stream_id}

用法和 SDK 示例

curl -X DELETE \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需

响应

架构

架构

getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet

获取动画图变量

/animation_graphs/avatar/variables

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

getAnimationGraphsAnimationGraphsGet

获取动画图

/animation_graphs

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

getStreamsStreamsGet

获取流

/streams

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

livenessLivenessGet

活跃度

/liveness

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

postSdrAddStreamSdrAddStreamPost

Post Sdr 添加流

/sdr/add_stream

用法和 SDK 示例

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

请求体参数

名称	描述
postSdrStreamsBodyModel *

响应

架构

架构

postSdrRemoveStreamSdrRemoveStreamPost

Post Sdr 删除流

/sdr/remove_stream

用法和 SDK 示例

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

请求体参数

名称	描述
deleteSdrStreamsBodyModel *

响应

架构

架构

postStreamsStreamIdStreamsStreamIdPost

Post 流 Stream Id

/streams/{stream_id}

用法和 SDK 示例

curl -X POST \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需

响应

架构

架构

readinessReadinessGet

就绪度

/readiness

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

statusHealthGet

健康检查

返回服务的当前状态。

/health

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

statusReadyGet

就绪度检查

返回服务的当前状态。

/ready

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

statusStartupGet

启动检查

返回服务的当前状态。

/startup

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

statusStatusGet

返回服务的当前状态

返回服务的当前状态。

/status

用法和 SDK 示例

curl -X GET \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

响应

架构

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut

通过流 ID 和值更新变量（可调用）

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

用法和 SDK 示例

curl -X PUT \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需
value*	字符串必需

响应

架构

架构

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesGestureStateValuePut

通过流 ID 和值更新变量（可调用）

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

用法和 SDK 示例

curl -X PUT \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需
value*	字符串必需

响应

架构

架构

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPositionStateValuePut

通过流 ID 和值更新变量（可调用）

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

用法和 SDK 示例

curl -X PUT \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需
value*	字符串必需

响应

架构

架构

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesPostureStateValuePut

通过流 ID 和值更新变量（可调用）

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

用法和 SDK 示例

curl -X PUT \
 -H "Accept: application/json" \
 "https://127.0.0.1/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);
}

作用域

参数

路径参数

名称	描述
stream_id*	字符串必需
value*	字符串必需

响应

架构

架构

动画图微服务

API 和 SDK 文档

默认

asyncAppDocsEndpointAsyncapiDocsGet

用法和 SDK 示例

作用域

参数

响应

asyncAppSchemaEndpointAsyncapiSchemaGet

用法和 SDK 示例

作用域

参数

响应

deleteStreamsStreamIdStreamsStreamIdDelete

用法和 SDK 示例

作用域

参数

响应

getAnimationGraphVariablesAnimationGraphsAvatarVariablesGet

用法和 SDK 示例

作用域

参数

响应

getAnimationGraphsAnimationGraphsGet

用法和 SDK 示例

作用域

参数

响应

getStreamsStreamsGet

用法和 SDK 示例

作用域

参数

响应

livenessLivenessGet

用法和 SDK 示例

作用域

参数

响应

postSdrAddStreamSdrAddStreamPost

用法和 SDK 示例

作用域

参数

响应

postSdrRemoveStreamSdrRemoveStreamPost

用法和 SDK 示例

作用域

参数

响应

postStreamsStreamIdStreamsStreamIdPost

用法和 SDK 示例

作用域

参数

响应

readinessReadinessGet

用法和 SDK 示例

作用域

参数

响应

statusHealthGet

用法和 SDK 示例

作用域

参数

响应

statusReadyGet

用法和 SDK 示例

作用域

参数

响应

statusStartupGet

用法和 SDK 示例

作用域

参数

响应

statusStatusGet

用法和 SDK 示例

作用域

参数

响应

updateVariableByStreamIdAndValueCallableStreamsStreamIdAnimationGraphsAvatarVariablesFacialGestureStateValuePut

用法和 SDK 示例