Omniverse Renderer Microservice

Default

asyncAppDocsEndpointAsyncapiDocsGet

Async App Docs Endpoint


/asyncapi/docs

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Query parameters
Name Description
app_name*
String
Required

Responses

asyncAppSchemaEndpointAsyncapiSchemaGet

Async App Schema Endpoint


/asyncapi/schema

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Query parameters
Name Description
app_name*
String
Required

Responses

deleteStreamsStreamIdStreamsStreamIdDelete

Delete Streams Stream Id


/streams/{stream_id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Path parameters
Name Description
stream_id*
String
Required

Responses

livenessLivenessGet

Liveness


/liveness

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses

postSdrAddStreamSdrAddStreamPost

Post Sdr Add Stream


/sdr/add_stream

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Body parameters
Name Description
postSdrStreamsBodyModel *

Responses

postSdrRemoveStreamSdrRemoveStreamPost

Post Sdr Remove Stream


/sdr/remove_stream

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Body parameters
Name Description
deleteSdrStreamsBodyModel *

Responses

postStreamsStreamIdStreamsStreamIdPost

Post Streams Stream Id


/streams/{stream_id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Path parameters
Name Description
stream_id*
String
Required

Responses

readinessReadinessGet

Readiness


/readiness

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses

statusHealthGet

Health probe

Returns the current status of the service.


/health

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses

statusReadyGet

Readiness probe

Returns the current status of the service.


/ready

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses

statusStartupGet

Startup probe

Returns the current status of the service.


/startup

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses

statusStatusGet

Returns the current status of the service

Returns the current status of the service.


/status

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.DefaultApi;

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

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


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

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

var 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);
}

Scopes

Parameters

Responses