import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ArchiverCreateClusterLogArchiveRequest body = ; // ArchiverCreateClusterLogArchiveRequest | 
        try {
            archiverCreateClusterLogArchiveResponse result = apiInstance.servingCreateClusterLogArchive(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingCreateClusterLogArchive");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ArchiverCreateClusterLogArchiveRequest body = ; // ArchiverCreateClusterLogArchiveRequest | 
        try {
            archiverCreateClusterLogArchiveResponse result = apiInstance.servingCreateClusterLogArchive(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingCreateClusterLogArchive");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ArchiverCreateClusterLogArchiveRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingCreateClusterLogArchiveWith:body
              completionHandler: ^(archiverCreateClusterLogArchiveResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ArchiverCreateClusterLogArchiveRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ArchiverCreateClusterLogArchiveRequest(); // ArchiverCreateClusterLogArchiveRequest | 

            try
            {
                archiverCreateClusterLogArchiveResponse result = apiInstance.servingCreateClusterLogArchive(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingCreateClusterLogArchive: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ArchiverCreateClusterLogArchiveRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ArchiverCreateClusterLogArchiveRequest->new(); # ArchiverCreateClusterLogArchiveRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ArchiverCreateClusterLogArchiveRequest | 

try: 
    api_response = api_instance.serving_create_cluster_log_archive(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingCreateClusterLogArchive: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDeleteApplicationRequest body = ; // ServingDeleteApplicationRequest | 
        try {
            servingDeleteApplicationResponse result = apiInstance.servingDeleteApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDeleteApplicationRequest body = ; // ServingDeleteApplicationRequest | 
        try {
            servingDeleteApplicationResponse result = apiInstance.servingDeleteApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteApplication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDeleteApplicationRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDeleteApplicationWith:body
              completionHandler: ^(servingDeleteApplicationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDeleteApplicationRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDeleteApplicationRequest(); // ServingDeleteApplicationRequest | 

            try
            {
                servingDeleteApplicationResponse result = apiInstance.servingDeleteApplication(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDeleteApplication: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDeleteApplicationRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDeleteApplicationRequest->new(); # ServingDeleteApplicationRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDeleteApplicationRequest | 

try: 
    api_response = api_instance.serving_delete_application(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDeleteApplication: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ArchiverDeleteClusterLogArchiveRequest body = ; // ArchiverDeleteClusterLogArchiveRequest | 
        try {
            archiverDeleteClusterLogArchiveResponse result = apiInstance.servingDeleteClusterLogArchive(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteClusterLogArchive");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ArchiverDeleteClusterLogArchiveRequest body = ; // ArchiverDeleteClusterLogArchiveRequest | 
        try {
            archiverDeleteClusterLogArchiveResponse result = apiInstance.servingDeleteClusterLogArchive(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteClusterLogArchive");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ArchiverDeleteClusterLogArchiveRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDeleteClusterLogArchiveWith:body
              completionHandler: ^(archiverDeleteClusterLogArchiveResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ArchiverDeleteClusterLogArchiveRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ArchiverDeleteClusterLogArchiveRequest(); // ArchiverDeleteClusterLogArchiveRequest | 

            try
            {
                archiverDeleteClusterLogArchiveResponse result = apiInstance.servingDeleteClusterLogArchive(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDeleteClusterLogArchive: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ArchiverDeleteClusterLogArchiveRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ArchiverDeleteClusterLogArchiveRequest->new(); # ArchiverDeleteClusterLogArchiveRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ArchiverDeleteClusterLogArchiveRequest | 

try: 
    api_response = api_instance.serving_delete_cluster_log_archive(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDeleteClusterLogArchive: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDeleteEndpointRequest body = ; // ServingDeleteEndpointRequest | 
        try {
            servingDeleteEndpointResponse result = apiInstance.servingDeleteEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteEndpoint");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDeleteEndpointRequest body = ; // ServingDeleteEndpointRequest | 
        try {
            servingDeleteEndpointResponse result = apiInstance.servingDeleteEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeleteEndpoint");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDeleteEndpointRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDeleteEndpointWith:body
              completionHandler: ^(servingDeleteEndpointResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDeleteEndpointRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDeleteEndpointRequest(); // ServingDeleteEndpointRequest | 

            try
            {
                servingDeleteEndpointResponse result = apiInstance.servingDeleteEndpoint(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDeleteEndpoint: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDeleteEndpointRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDeleteEndpointRequest->new(); # ServingDeleteEndpointRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDeleteEndpointRequest | 

try: 
    api_response = api_instance.serving_delete_endpoint(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDeleteEndpoint: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDeployApplicationRequest body = ; // ServingDeployApplicationRequest | 
        try {
            servingDeployApplicationResponse result = apiInstance.servingDeployApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeployApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDeployApplicationRequest body = ; // ServingDeployApplicationRequest | 
        try {
            servingDeployApplicationResponse result = apiInstance.servingDeployApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeployApplication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDeployApplicationRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDeployApplicationWith:body
              completionHandler: ^(servingDeployApplicationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDeployApplicationRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDeployApplicationRequest(); // ServingDeployApplicationRequest | 

            try
            {
                servingDeployApplicationResponse result = apiInstance.servingDeployApplication(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDeployApplication: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDeployApplicationRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDeployApplicationRequest->new(); # ServingDeployApplicationRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDeployApplicationRequest | 

try: 
    api_response = api_instance.serving_deploy_application(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDeployApplication: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDeployEndpointRequest body = ; // ServingDeployEndpointRequest | 
        try {
            servingDeployEndpointResponse result = apiInstance.servingDeployEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeployEndpoint");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDeployEndpointRequest body = ; // ServingDeployEndpointRequest | 
        try {
            servingDeployEndpointResponse result = apiInstance.servingDeployEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDeployEndpoint");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDeployEndpointRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDeployEndpointWith:body
              completionHandler: ^(servingDeployEndpointResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDeployEndpointRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDeployEndpointRequest(); // ServingDeployEndpointRequest | 

            try
            {
                servingDeployEndpointResponse result = apiInstance.servingDeployEndpoint(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDeployEndpoint: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDeployEndpointRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDeployEndpointRequest->new(); # ServingDeployEndpointRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDeployEndpointRequest | 

try: 
    api_response = api_instance.serving_deploy_endpoint(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDeployEndpoint: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDescribeApplicationRequest body = ; // ServingDescribeApplicationRequest | 
        try {
            servingDescribeApplicationResponse result = apiInstance.servingDescribeApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDescribeApplication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDescribeApplicationRequest body = ; // ServingDescribeApplicationRequest | 
        try {
            servingDescribeApplicationResponse result = apiInstance.servingDescribeApplication(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDescribeApplication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDescribeApplicationRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDescribeApplicationWith:body
              completionHandler: ^(servingDescribeApplicationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDescribeApplicationRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDescribeApplicationRequest(); // ServingDescribeApplicationRequest | 

            try
            {
                servingDescribeApplicationResponse result = apiInstance.servingDescribeApplication(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDescribeApplication: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDescribeApplicationRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDescribeApplicationRequest->new(); # ServingDescribeApplicationRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDescribeApplicationRequest | 

try: 
    api_response = api_instance.serving_describe_application(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDescribeApplication: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingDescribeEndpointRequest body = ; // ServingDescribeEndpointRequest | 
        try {
            servingDescribeEndpointResponse result = apiInstance.servingDescribeEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDescribeEndpoint");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingDescribeEndpointRequest body = ; // ServingDescribeEndpointRequest | 
        try {
            servingDescribeEndpointResponse result = apiInstance.servingDescribeEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingDescribeEndpoint");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingDescribeEndpointRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingDescribeEndpointWith:body
              completionHandler: ^(servingDescribeEndpointResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingDescribeEndpointRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingDescribeEndpointRequest(); // ServingDescribeEndpointRequest | 

            try
            {
                servingDescribeEndpointResponse result = apiInstance.servingDescribeEndpoint(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingDescribeEndpoint: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingDescribeEndpointRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingDescribeEndpointRequest->new(); # ServingDescribeEndpointRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingDescribeEndpointRequest | 

try: 
    api_response = api_instance.serving_describe_endpoint(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingDescribeEndpoint: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingGetAPILogsRequest body = ; // ServingGetAPILogsRequest | 
        try {
            servingGetAPILogsResponse result = apiInstance.servingGetAPILogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetAPILogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingGetAPILogsRequest body = ; // ServingGetAPILogsRequest | 
        try {
            servingGetAPILogsResponse result = apiInstance.servingGetAPILogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetAPILogs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingGetAPILogsRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingGetAPILogsWith:body
              completionHandler: ^(servingGetAPILogsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingGetAPILogsRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingGetAPILogsRequest(); // ServingGetAPILogsRequest | 

            try
            {
                servingGetAPILogsResponse result = apiInstance.servingGetAPILogs(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingGetAPILogs: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingGetAPILogsRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingGetAPILogsRequest->new(); # ServingGetAPILogsRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingGetAPILogsRequest | 

try: 
    api_response = api_instance.serving_get_api_logs(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingGetAPILogs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingGetApplicationLogsRequest body = ; // ServingGetApplicationLogsRequest | 
        try {
            servingGetApplicationLogsResponse result = apiInstance.servingGetApplicationLogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetApplicationLogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingGetApplicationLogsRequest body = ; // ServingGetApplicationLogsRequest | 
        try {
            servingGetApplicationLogsResponse result = apiInstance.servingGetApplicationLogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetApplicationLogs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingGetApplicationLogsRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingGetApplicationLogsWith:body
              completionHandler: ^(servingGetApplicationLogsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingGetApplicationLogsRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingGetApplicationLogsRequest(); // ServingGetApplicationLogsRequest | 

            try
            {
                servingGetApplicationLogsResponse result = apiInstance.servingGetApplicationLogs(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingGetApplicationLogs: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingGetApplicationLogsRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingGetApplicationLogsRequest->new(); # ServingGetApplicationLogsRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingGetApplicationLogsRequest | 

try: 
    api_response = api_instance.serving_get_application_logs(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingGetApplicationLogs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingGetEndpointEventRequest body = ; // ServingGetEndpointEventRequest | 
        try {
            servingGetEndpointEventResponse result = apiInstance.servingGetEndpointEvents(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetEndpointEvents");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingGetEndpointEventRequest body = ; // ServingGetEndpointEventRequest | 
        try {
            servingGetEndpointEventResponse result = apiInstance.servingGetEndpointEvents(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetEndpointEvents");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingGetEndpointEventRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingGetEndpointEventsWith:body
              completionHandler: ^(servingGetEndpointEventResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingGetEndpointEventRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingGetEndpointEventRequest(); // ServingGetEndpointEventRequest | 

            try
            {
                servingGetEndpointEventResponse result = apiInstance.servingGetEndpointEvents(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingGetEndpointEvents: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingGetEndpointEventRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingGetEndpointEventRequest->new(); # ServingGetEndpointEventRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingGetEndpointEventRequest | 

try: 
    api_response = api_instance.serving_get_endpoint_events(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingGetEndpointEvents: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingGetEndpointLogsRequest body = ; // ServingGetEndpointLogsRequest | 
        try {
            servingGetEndpointLogsResponse result = apiInstance.servingGetEndpointLogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetEndpointLogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingGetEndpointLogsRequest body = ; // ServingGetEndpointLogsRequest | 
        try {
            servingGetEndpointLogsResponse result = apiInstance.servingGetEndpointLogs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingGetEndpointLogs");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingGetEndpointLogsRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingGetEndpointLogsWith:body
              completionHandler: ^(servingGetEndpointLogsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingGetEndpointLogsRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingGetEndpointLogsRequest(); // ServingGetEndpointLogsRequest | 

            try
            {
                servingGetEndpointLogsResponse result = apiInstance.servingGetEndpointLogs(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingGetEndpointLogs: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingGetEndpointLogsRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingGetEndpointLogsRequest->new(); # ServingGetEndpointLogsRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingGetEndpointLogsRequest | 

try: 
    api_response = api_instance.serving_get_endpoint_logs(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingGetEndpointLogs: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingListApplicationsRequest body = ; // ServingListApplicationsRequest | 
        try {
            servingListApplicationsResponse result = apiInstance.servingListApplications(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListApplications");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingListApplicationsRequest body = ; // ServingListApplicationsRequest | 
        try {
            servingListApplicationsResponse result = apiInstance.servingListApplications(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListApplications");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingListApplicationsRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingListApplicationsWith:body
              completionHandler: ^(servingListApplicationsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingListApplicationsRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingListApplicationsRequest(); // ServingListApplicationsRequest | 

            try
            {
                servingListApplicationsResponse result = apiInstance.servingListApplications(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingListApplications: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingListApplicationsRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingListApplicationsRequest->new(); # ServingListApplicationsRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingListApplicationsRequest | 

try: 
    api_response = api_instance.serving_list_applications(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingListApplications: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ArchiverListClusterLogArchivesRequest body = ; // ArchiverListClusterLogArchivesRequest | 
        try {
            archiverListClusterLogArchivesResponse result = apiInstance.servingListClusterLogArchives(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListClusterLogArchives");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ArchiverListClusterLogArchivesRequest body = ; // ArchiverListClusterLogArchivesRequest | 
        try {
            archiverListClusterLogArchivesResponse result = apiInstance.servingListClusterLogArchives(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListClusterLogArchives");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ArchiverListClusterLogArchivesRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingListClusterLogArchivesWith:body
              completionHandler: ^(archiverListClusterLogArchivesResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ArchiverListClusterLogArchivesRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ArchiverListClusterLogArchivesRequest(); // ArchiverListClusterLogArchivesRequest | 

            try
            {
                archiverListClusterLogArchivesResponse result = apiInstance.servingListClusterLogArchives(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingListClusterLogArchives: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ArchiverListClusterLogArchivesRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ArchiverListClusterLogArchivesRequest->new(); # ArchiverListClusterLogArchivesRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ArchiverListClusterLogArchivesRequest | 

try: 
    api_response = api_instance.serving_list_cluster_log_archives(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingListClusterLogArchives: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingListEndpointsRequest body = ; // ServingListEndpointsRequest | 
        try {
            servingListEndpointsResponse result = apiInstance.servingListEndpoints(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListEndpoints");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingListEndpointsRequest body = ; // ServingListEndpointsRequest | 
        try {
            servingListEndpointsResponse result = apiInstance.servingListEndpoints(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingListEndpoints");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingListEndpointsRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingListEndpointsWith:body
              completionHandler: ^(servingListEndpointsResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingListEndpointsRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingListEndpointsRequest(); // ServingListEndpointsRequest | 

            try
            {
                servingListEndpointsResponse result = apiInstance.servingListEndpoints(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingListEndpoints: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingListEndpointsRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingListEndpointsRequest->new(); # ServingListEndpointsRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingListEndpointsRequest | 

try: 
    api_response = api_instance.serving_list_endpoints(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingListEndpoints: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ServingApi;

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

public class ServingApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: Bearer
        ApiKeyAuth Bearer = (ApiKeyAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //Bearer.setApiKeyPrefix("Token");

        ServingApi apiInstance = new ServingApi();
        ServingUpdateEndpointRequest body = ; // ServingUpdateEndpointRequest | 
        try {
            servingUpdateEndpointResponse result = apiInstance.servingUpdateEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingUpdateEndpoint");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ServingApi;

public class ServingApiExample {

    public static void main(String[] args) {
        ServingApi apiInstance = new ServingApi();
        ServingUpdateEndpointRequest body = ; // ServingUpdateEndpointRequest | 
        try {
            servingUpdateEndpointResponse result = apiInstance.servingUpdateEndpoint(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServingApi#servingUpdateEndpoint");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: Bearer)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
ServingUpdateEndpointRequest *body = ; // 

ServingApi *apiInstance = [[ServingApi alloc] init];

[apiInstance servingUpdateEndpointWith:body
              completionHandler: ^(servingUpdateEndpointResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var ClouderaAiInference = require('cloudera_ai_inference');
var defaultClient = ClouderaAiInference.ApiClient.instance;

// Configure API key authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//Bearer.apiKeyPrefix['Authorization'] = "Token"

var api = new ClouderaAiInference.ServingApi()
var body = ; // {{ServingUpdateEndpointRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // Configure API key authorization: Bearer
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new ServingApi();
            var body = new ServingUpdateEndpointRequest(); // ServingUpdateEndpointRequest | 

            try
            {
                servingUpdateEndpointResponse result = apiInstance.servingUpdateEndpoint(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ServingApi.servingUpdateEndpoint: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: Bearer
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\ApiServingApi();
$body = ; // ServingUpdateEndpointRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ServingApi;

# Configure API key authorization: Bearer
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::ServingApi->new();
my $body = WWW::SwaggerClient::Object::ServingUpdateEndpointRequest->new(); # ServingUpdateEndpointRequest | 

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

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

# Configure API key authorization: Bearer
swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ServingApi()
body =  # ServingUpdateEndpointRequest | 

try: 
    api_response = api_instance.serving_update_endpoint(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServingApi->servingUpdateEndpoint: %s\n" % e)