Omniverse 渲染器微服务

默认

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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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*	字符串必需

响应

模式

模式

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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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 OmniverseRendererMicroservice = require('omniverse_renderer_microservice');

// Create an instance of the API class
var api = new OmniverseRendererMicroservice.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);
}

作用域

参数

响应

模式

Omniverse 渲染器微服务

API 和 SDK 文档

默认

asyncAppDocsEndpointAsyncapiDocsGet

用法和 SDK 示例

作用域

参数

响应

asyncAppSchemaEndpointAsyncapiSchemaGet

用法和 SDK 示例

作用域

参数

响应

deleteStreamsStreamIdStreamsStreamIdDelete

用法和 SDK 示例

作用域

参数

响应

livenessLivenessGet

用法和 SDK 示例

作用域

参数

响应

postSdrAddStreamSdrAddStreamPost

用法和 SDK 示例

作用域

参数

响应

postSdrRemoveStreamSdrRemoveStreamPost

用法和 SDK 示例

作用域

参数

响应

postStreamsStreamIdStreamsStreamIdPost

用法和 SDK 示例

作用域

参数

响应

readinessReadinessGet

用法和 SDK 示例

作用域

参数

响应

statusHealthGet

用法和 SDK 示例

作用域

参数

响应

statusReadyGet

用法和 SDK 示例

作用域

参数

响应

statusStartupGet

用法和 SDK 示例

作用域

参数

响应

statusStatusGet

用法和 SDK 示例

作用域

参数

响应