RPET API

API

petApiLoginPost

Login and Get token from remote pet


/pet/api/login

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/api/login"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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


        APIApi apiInstance = new APIApi();
        Api_login_body body = ; // Api_login_body | 
        try {
            inline_response_200_1 result = apiInstance.petApiLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiLoginPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        Api_login_body body = ; // Api_login_body | 
        try {
            inline_response_200_1 result = apiInstance.petApiLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiLoginPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
Api_login_body *body = ; // 

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

// Login and Get token from remote pet
[apiInstance petApiLoginPostWith:body
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;


var api = new RpetApi.APIApi()
var body = ; // {{Api_login_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petApiLoginPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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


            var apiInstance = new APIApi();
            var body = new Api_login_body(); // Api_login_body | 

            try
            {
                // Login and Get token from remote pet
                inline_response_200_1 result = apiInstance.petApiLoginPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiLoginPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiAPIApi();
$body = ; // Api_login_body | 

try {
    $result = $api_instance->petApiLoginPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiLoginPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;


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

eval { 
    my $result = $api_instance->petApiLoginPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIApi->petApiLoginPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


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

try: 
    # Login and Get token from remote pet
    api_response = api_instance.pet_api_login_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIApi->petApiLoginPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Login and API init OK

Status: 401 - Invalid credentials

Status: 500 - An error occurred while login


petApiLogoutPost

Logs a user out and invalidates the token


/pet/api/logout

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
"{server}/pw/v1/pet/api/logout"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiLogoutPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiLogoutPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiLogoutPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiLogoutPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Logs a user out and invalidates the token
[apiInstance petApiLogoutPostWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiLogoutPost(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();

            try
            {
                // Logs a user out and invalidates the token
                apiInstance.petApiLogoutPost();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiLogoutPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();

try {
    $api_instance->petApiLogoutPost();
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiLogoutPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

my $api_instance = WWW::SwaggerClient::APIApi->new();

eval { 
    $api_instance->petApiLogoutPost();
};
if ($@) {
    warn "Exception when calling APIApi->petApiLogoutPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.APIApi()

try: 
    # Logs a user out and invalidates the token
    api_instance.pet_api_logout_post()
except ApiException as e:
    print("Exception when calling APIApi->petApiLogoutPost: %s\n" % e)

Parameters

Responses

Status: 204 - logout ok


petApiPermissionAddPost

Add user


/pet/api/permission/add

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/api/permission/add"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        Permission_add_body body = ; // Permission_add_body | 
        try {
            apiInstance.petApiPermissionAddPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionAddPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        Permission_add_body body = ; // Permission_add_body | 
        try {
            apiInstance.petApiPermissionAddPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionAddPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Permission_add_body *body = ; // 

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

// Add user
[apiInstance petApiPermissionAddPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var body = ; // {{Permission_add_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiPermissionAddPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();
            var body = new Permission_add_body(); // Permission_add_body | 

            try
            {
                // Add user
                apiInstance.petApiPermissionAddPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionAddPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();
$body = ; // Permission_add_body | 

try {
    $api_instance->petApiPermissionAddPost($body);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionAddPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

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

eval { 
    $api_instance->petApiPermissionAddPost(body => $body);
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionAddPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Add user
    api_instance.pet_api_permission_add_post(body)
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionAddPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Successfully create the user.

Status: 401 - Unauthorized to create user.

Status: 500 - An error occurred while create the user.


petApiPermissionDeletePost

Delete user


/pet/api/permission/delete

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/api/permission/delete"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        Permission_delete_body body = ; // Permission_delete_body | 
        try {
            apiInstance.petApiPermissionDeletePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionDeletePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        Permission_delete_body body = ; // Permission_delete_body | 
        try {
            apiInstance.petApiPermissionDeletePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionDeletePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Permission_delete_body *body = ; // 

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

// Delete user
[apiInstance petApiPermissionDeletePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var body = ; // {{Permission_delete_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiPermissionDeletePost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();
            var body = new Permission_delete_body(); // Permission_delete_body | 

            try
            {
                // Delete user
                apiInstance.petApiPermissionDeletePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionDeletePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();
$body = ; // Permission_delete_body | 

try {
    $api_instance->petApiPermissionDeletePost($body);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionDeletePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

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

eval { 
    $api_instance->petApiPermissionDeletePost(body => $body);
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionDeletePost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Delete user
    api_instance.pet_api_permission_delete_post(body)
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionDeletePost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Successfully delete the user.

Status: 401 - Unauthorized to disable permission control.

Status: 500 - An error occurred while turn off permission control.


petApiPermissionGet

Retrieves user data of all users


/pet/api/permission

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/api/permission"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        try {
            array[inline_response_200_2] result = apiInstance.petApiPermissionGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        try {
            array[inline_response_200_2] result = apiInstance.petApiPermissionGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves user data of all users
[apiInstance petApiPermissionGetWithCompletionHandler: 
              ^(array[inline_response_200_2] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petApiPermissionGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();

            try
            {
                // Retrieves user data of all users
                array[inline_response_200_2] result = apiInstance.petApiPermissionGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();

try {
    $result = $api_instance->petApiPermissionGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

my $api_instance = WWW::SwaggerClient::APIApi->new();

eval { 
    my $result = $api_instance->petApiPermissionGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.APIApi()

try: 
    # Retrieves user data of all users
    api_response = api_instance.pet_api_permission_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionGet: %s\n" % e)

Parameters

Responses

Status: 200 - Successfully get user data.

Status: 401 - Unauthorized to get user data.

Status: 500 - An error occurred while get user data.


petApiPermissionOffPost

Turn off permission control.


/pet/api/permission/off

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
"{server}/pw/v1/pet/api/permission/off"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiPermissionOffPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionOffPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiPermissionOffPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionOffPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Turn off permission control.
[apiInstance petApiPermissionOffPostWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiPermissionOffPost(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();

            try
            {
                // Turn off permission control.
                apiInstance.petApiPermissionOffPost();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionOffPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();

try {
    $api_instance->petApiPermissionOffPost();
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionOffPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

my $api_instance = WWW::SwaggerClient::APIApi->new();

eval { 
    $api_instance->petApiPermissionOffPost();
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionOffPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.APIApi()

try: 
    # Turn off permission control.
    api_instance.pet_api_permission_off_post()
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionOffPost: %s\n" % e)

Parameters

Responses

Status: 200 - Successfully turned off permission control.

Status: 401 - Unauthorized to disable permission control.

Status: 500 - An error occurred while turn off permission control.


petApiPermissionOnPost

Turn on permission control.


/pet/api/permission/on

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
"{server}/pw/v1/pet/api/permission/on"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiPermissionOnPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionOnPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        try {
            apiInstance.petApiPermissionOnPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionOnPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Turn on permission control.
[apiInstance petApiPermissionOnPostWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiPermissionOnPost(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();

            try
            {
                // Turn on permission control.
                apiInstance.petApiPermissionOnPost();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionOnPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();

try {
    $api_instance->petApiPermissionOnPost();
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionOnPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

my $api_instance = WWW::SwaggerClient::APIApi->new();

eval { 
    $api_instance->petApiPermissionOnPost();
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionOnPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.APIApi()

try: 
    # Turn on permission control.
    api_instance.pet_api_permission_on_post()
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionOnPost: %s\n" % e)

Parameters

Responses

Status: 200 - Successfully turned on permission control.

Status: 500 - An error occurred while turn on permission control.


petApiPermissionUpdatePost

Modify permission data of target user


/pet/api/permission/update

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/api/permission/update"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        Permission_update_body body = ; // Permission_update_body | 
        try {
            apiInstance.petApiPermissionUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionUpdatePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        Permission_update_body body = ; // Permission_update_body | 
        try {
            apiInstance.petApiPermissionUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiPermissionUpdatePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Permission_update_body *body = ; // 

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

// Modify permission data of target user
[apiInstance petApiPermissionUpdatePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var body = ; // {{Permission_update_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petApiPermissionUpdatePost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();
            var body = new Permission_update_body(); // Permission_update_body | 

            try
            {
                // Modify permission data of target user
                apiInstance.petApiPermissionUpdatePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiPermissionUpdatePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();
$body = ; // Permission_update_body | 

try {
    $api_instance->petApiPermissionUpdatePost($body);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiPermissionUpdatePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

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

eval { 
    $api_instance->petApiPermissionUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling APIApi->petApiPermissionUpdatePost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Modify permission data of target user
    api_instance.pet_api_permission_update_post(body)
except ApiException as e:
    print("Exception when calling APIApi->petApiPermissionUpdatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Successfully update the user data.

Status: 401 - Unauthorized to update the user data.

Status: 500 - An error occurred while update the user data.


petApiVersionGet

Retrieves API version


/pet/api/version

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/api/version"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.APIApi;

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

public class APIApiExample {

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

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

        APIApi apiInstance = new APIApi();
        try {
            inline_response_200_3 result = apiInstance.petApiVersionGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiVersionGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.APIApi;

public class APIApiExample {

    public static void main(String[] args) {
        APIApi apiInstance = new APIApi();
        try {
            inline_response_200_3 result = apiInstance.petApiVersionGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling APIApi#petApiVersionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves API version
[apiInstance petApiVersionGetWithCompletionHandler: 
              ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.APIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petApiVersionGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new APIApi();

            try
            {
                // Retrieves API version
                inline_response_200_3 result = apiInstance.petApiVersionGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling APIApi.petApiVersionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiAPIApi();

try {
    $result = $api_instance->petApiVersionGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling APIApi->petApiVersionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::APIApi;

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

my $api_instance = WWW::SwaggerClient::APIApi->new();

eval { 
    my $result = $api_instance->petApiVersionGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling APIApi->petApiVersionGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.APIApi()

try: 
    # Retrieves API version
    api_response = api_instance.pet_api_version_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling APIApi->petApiVersionGet: %s\n" % e)

Parameters

Responses

Status: 200 - API version retrieved successfully.

Status: 500 - An error occurred while retrieving API version


BoardInfo

petBoardBiosGet

Retrieves BIOS information for a board


/pet/board/bios

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/board/bios"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BoardInfoApi;

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

public class BoardInfoApiExample {

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

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

        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_5 result = apiInstance.petBoardBiosGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardBiosGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BoardInfoApi;

public class BoardInfoApiExample {

    public static void main(String[] args) {
        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_5 result = apiInstance.petBoardBiosGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardBiosGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves BIOS information for a board
[apiInstance petBoardBiosGetWithCompletionHandler: 
              ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.BoardInfoApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petBoardBiosGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new BoardInfoApi();

            try
            {
                // Retrieves BIOS information for a board
                inline_response_200_5 result = apiInstance.petBoardBiosGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BoardInfoApi.petBoardBiosGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiBoardInfoApi();

try {
    $result = $api_instance->petBoardBiosGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BoardInfoApi->petBoardBiosGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BoardInfoApi;

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

my $api_instance = WWW::SwaggerClient::BoardInfoApi->new();

eval { 
    my $result = $api_instance->petBoardBiosGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BoardInfoApi->petBoardBiosGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.BoardInfoApi()

try: 
    # Retrieves BIOS information for a board
    api_response = api_instance.pet_board_bios_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BoardInfoApi->petBoardBiosGet: %s\n" % e)

Parameters

Responses

Status: 200 - BIOS information retrieved successfully.

Status: 500 - An error occurred while retrieving bios information


petBoardEcGet

Retrieves EC information for a board


/pet/board/ec

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/board/ec"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BoardInfoApi;

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

public class BoardInfoApiExample {

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

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

        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_6 result = apiInstance.petBoardEcGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardEcGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BoardInfoApi;

public class BoardInfoApiExample {

    public static void main(String[] args) {
        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_6 result = apiInstance.petBoardEcGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardEcGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves EC information for a board
[apiInstance petBoardEcGetWithCompletionHandler: 
              ^(inline_response_200_6 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.BoardInfoApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petBoardEcGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new BoardInfoApi();

            try
            {
                // Retrieves EC information for a board
                inline_response_200_6 result = apiInstance.petBoardEcGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BoardInfoApi.petBoardEcGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiBoardInfoApi();

try {
    $result = $api_instance->petBoardEcGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BoardInfoApi->petBoardEcGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BoardInfoApi;

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

my $api_instance = WWW::SwaggerClient::BoardInfoApi->new();

eval { 
    my $result = $api_instance->petBoardEcGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BoardInfoApi->petBoardEcGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.BoardInfoApi()

try: 
    # Retrieves EC information for a board
    api_response = api_instance.pet_board_ec_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BoardInfoApi->petBoardEcGet: %s\n" % e)

Parameters

Responses

Status: 200 - EC firmware information retrieved successfully.

Status: 500 - An error occurred while retrieving EC information


petBoardGet

Retrieves all board firmware information


/pet/board

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/board"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BoardInfoApi;

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

public class BoardInfoApiExample {

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

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

        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_4 result = apiInstance.petBoardGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BoardInfoApi;

public class BoardInfoApiExample {

    public static void main(String[] args) {
        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200_4 result = apiInstance.petBoardGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves all board firmware information
[apiInstance petBoardGetWithCompletionHandler: 
              ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.BoardInfoApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petBoardGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new BoardInfoApi();

            try
            {
                // Retrieves all board firmware information
                inline_response_200_4 result = apiInstance.petBoardGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BoardInfoApi.petBoardGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiBoardInfoApi();

try {
    $result = $api_instance->petBoardGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BoardInfoApi->petBoardGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BoardInfoApi;

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

my $api_instance = WWW::SwaggerClient::BoardInfoApi->new();

eval { 
    my $result = $api_instance->petBoardGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BoardInfoApi->petBoardGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.BoardInfoApi()

try: 
    # Retrieves all board firmware information
    api_response = api_instance.pet_board_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BoardInfoApi->petBoardGet: %s\n" % e)

Parameters

Responses

Status: 200 - Board information retrieved successfully.

Status: 500 - An error occurred while retrieving board information


petBoardPlatformGet

Retrieves platform information for a board


/pet/board/platform

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/board/platform"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BoardInfoApi;

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

public class BoardInfoApiExample {

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

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

        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200 result = apiInstance.petBoardPlatformGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardPlatformGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BoardInfoApi;

public class BoardInfoApiExample {

    public static void main(String[] args) {
        BoardInfoApi apiInstance = new BoardInfoApi();
        try {
            inline_response_200 result = apiInstance.petBoardPlatformGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BoardInfoApi#petBoardPlatformGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Retrieves platform information for a board
[apiInstance petBoardPlatformGetWithCompletionHandler: 
              ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.BoardInfoApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petBoardPlatformGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new BoardInfoApi();

            try
            {
                // Retrieves platform information for a board
                inline_response_200 result = apiInstance.petBoardPlatformGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BoardInfoApi.petBoardPlatformGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiBoardInfoApi();

try {
    $result = $api_instance->petBoardPlatformGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BoardInfoApi->petBoardPlatformGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BoardInfoApi;

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

my $api_instance = WWW::SwaggerClient::BoardInfoApi->new();

eval { 
    my $result = $api_instance->petBoardPlatformGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BoardInfoApi->petBoardPlatformGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.BoardInfoApi()

try: 
    # Retrieves platform information for a board
    api_response = api_instance.pet_board_platform_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BoardInfoApi->petBoardPlatformGet: %s\n" % e)

Parameters

Responses

Status: 200 - Board platform information retrieved successfully.

Status: 500 - An error occurred while retrieving platform information


ECI2C

petEciicByteAddrOffsetLengthGet

Send EC I2C Byte Read Command


/pet/eciic/byte/{addr}/{offset}/{length}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/byte/{addr}/{offset}/{length}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to read
        try {
            cmd_count_body result = apiInstance.petEciicByteAddrOffsetLengthGet(addr, offset, length);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicByteAddrOffsetLengthGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to read
        try {
            cmd_count_body result = apiInstance.petEciicByteAddrOffsetLengthGet(addr, offset, length);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicByteAddrOffsetLengthGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *offset = offset_example; // Offset parameter in hexadecimal format
Integer *length = 56; // Number of bytes to read

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

// Send EC I2C Byte Read Command
[apiInstance petEciicByteAddrOffsetLengthGetWith:addr
    offset:offset
    length:length
              completionHandler: ^(cmd_count_body output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var offset = offset_example; // {{String}} Offset parameter in hexadecimal format
var length = 56; // {{Integer}} Number of bytes to read

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petEciicByteAddrOffsetLengthGet(addr, offset, length, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var offset = offset_example;  // String | Offset parameter in hexadecimal format
            var length = 56;  // Integer | Number of bytes to read

            try
            {
                // Send EC I2C Byte Read Command
                cmd_count_body result = apiInstance.petEciicByteAddrOffsetLengthGet(addr, offset, length);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicByteAddrOffsetLengthGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$offset = offset_example; // String | Offset parameter in hexadecimal format
$length = 56; // Integer | Number of bytes to read

try {
    $result = $api_instance->petEciicByteAddrOffsetLengthGet($addr, $offset, $length);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $offset = offset_example; # String | Offset parameter in hexadecimal format
my $length = 56; # Integer | Number of bytes to read

eval { 
    my $result = $api_instance->petEciicByteAddrOffsetLengthGet(addr => $addr, offset => $offset, length => $length);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format
offset = offset_example # String | Offset parameter in hexadecimal format
length = 56 # Integer | Number of bytes to read

try: 
    # Send EC I2C Byte Read Command
    api_response = api_instance.pet_eciic_byte_addr_offset_length_get(addr, offset, length)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
offset*
String
Offset parameter in hexadecimal format
Required
length*
Integer
Number of bytes to read
Required

Responses

Status: 200 - Byte read successfully

Status: 500 - An error occurred while send EC I2C byte read Command.


petEciicByteAddrOffsetLengthPost

Send EC I2C Byte Write Command


/pet/eciic/byte/{addr}/{offset}/{length}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/eciic/byte/{addr}/{offset}/{length}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        Offset_length_body body = ; // Offset_length_body | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petEciicByteAddrOffsetLengthPost(body, addr, offset, length);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicByteAddrOffsetLengthPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        Offset_length_body body = ; // Offset_length_body | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petEciicByteAddrOffsetLengthPost(body, addr, offset, length);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicByteAddrOffsetLengthPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Offset_length_body *body = ; // 
String *addr = addr_example; // Address parameter in hexadecimal format
String *offset = offset_example; // Offset parameter in hexadecimal format
Integer *length = 56; // Number of bytes to write

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

// Send EC I2C Byte Write Command
[apiInstance petEciicByteAddrOffsetLengthPostWith:body
    addr:addr
    offset:offset
    length:length
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var body = ; // {{Offset_length_body}} 
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var offset = offset_example; // {{String}} Offset parameter in hexadecimal format
var length = 56; // {{Integer}} Number of bytes to write

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicByteAddrOffsetLengthPost(bodyaddroffsetlength, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var body = new Offset_length_body(); // Offset_length_body | 
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var offset = offset_example;  // String | Offset parameter in hexadecimal format
            var length = 56;  // Integer | Number of bytes to write

            try
            {
                // Send EC I2C Byte Write Command
                apiInstance.petEciicByteAddrOffsetLengthPost(body, addr, offset, length);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicByteAddrOffsetLengthPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$body = ; // Offset_length_body | 
$addr = addr_example; // String | Address parameter in hexadecimal format
$offset = offset_example; // String | Offset parameter in hexadecimal format
$length = 56; // Integer | Number of bytes to write

try {
    $api_instance->petEciicByteAddrOffsetLengthPost($body, $addr, $offset, $length);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $body = WWW::SwaggerClient::Object::Offset_length_body->new(); # Offset_length_body | 
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $offset = offset_example; # String | Offset parameter in hexadecimal format
my $length = 56; # Integer | Number of bytes to write

eval { 
    $api_instance->petEciicByteAddrOffsetLengthPost(body => $body, addr => $addr, offset => $offset, length => $length);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
body =  # Offset_length_body | 
addr = addr_example # String | Address parameter in hexadecimal format
offset = offset_example # String | Offset parameter in hexadecimal format
length = 56 # Integer | Number of bytes to write

try: 
    # Send EC I2C Byte Write Command
    api_instance.pet_eciic_byte_addr_offset_length_post(body, addr, offset, length)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicByteAddrOffsetLengthPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
offset*
String
Offset parameter in hexadecimal format
Required
length*
Integer
Number of bytes to write
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Byte sent successfully

Status: 500 - An error occurred while send EC I2C byte write Command.


petEciicFrequencyFrequencyPost

Set EC I2C Frequency

Set the Frequency of EC I2C.


/pet/eciic/frequency/{frequency}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/frequency/{frequency}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        Integer frequency = 56; // Integer | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicFrequencyFrequencyPost(frequency);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicFrequencyFrequencyPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        Integer frequency = 56; // Integer | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicFrequencyFrequencyPost(frequency);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicFrequencyFrequencyPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Integer *frequency = 56; // Address parameter in hexadecimal format

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

// Set EC I2C Frequency
[apiInstance petEciicFrequencyFrequencyPostWith:frequency
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var frequency = 56; // {{Integer}} Address parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicFrequencyFrequencyPost(frequency, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var frequency = 56;  // Integer | Address parameter in hexadecimal format

            try
            {
                // Set EC I2C Frequency
                apiInstance.petEciicFrequencyFrequencyPost(frequency);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicFrequencyFrequencyPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$frequency = 56; // Integer | Address parameter in hexadecimal format

try {
    $api_instance->petEciicFrequencyFrequencyPost($frequency);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicFrequencyFrequencyPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $frequency = 56; # Integer | Address parameter in hexadecimal format

eval { 
    $api_instance->petEciicFrequencyFrequencyPost(frequency => $frequency);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicFrequencyFrequencyPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
frequency = 56 # Integer | Address parameter in hexadecimal format

try: 
    # Set EC I2C Frequency
    api_instance.pet_eciic_frequency_frequency_post(frequency)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicFrequencyFrequencyPost: %s\n" % e)

Parameters

Path parameters
Name Description
frequency*
Integer
Address parameter in hexadecimal format
Required

Responses

Status: 200 - Successful Set EC I2C Frequency.

Status: 500 - An error occurred while retrieving EC I2C Frequency.


petEciicQuickAddrGet

Send EC I2C Quick Read Command


/pet/eciic/quick/{addr}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/quick/{addr}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicQuickAddrGet(addr);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicQuickAddrGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicQuickAddrGet(addr);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicQuickAddrGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format

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

// Send EC I2C Quick Read Command
[apiInstance petEciicQuickAddrGetWith:addr
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicQuickAddrGet(addr, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format

            try
            {
                // Send EC I2C Quick Read Command
                apiInstance.petEciicQuickAddrGet(addr);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicQuickAddrGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format

try {
    $api_instance->petEciicQuickAddrGet($addr);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicQuickAddrGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format

eval { 
    $api_instance->petEciicQuickAddrGet(addr => $addr);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicQuickAddrGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format

try: 
    # Send EC I2C Quick Read Command
    api_instance.pet_eciic_quick_addr_get(addr)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicQuickAddrGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required

Responses

Status: 200 - EC I2C Quick Command sent successfully

Status: 500 - An error occurred while send EC I2C Quick Read Command.


petEciicQuickAddrPost

Send EC I2C Quick Write Command


/pet/eciic/quick/{addr}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/quick/{addr}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicQuickAddrPost(addr);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicQuickAddrPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            apiInstance.petEciicQuickAddrPost(addr);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicQuickAddrPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format

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

// Send EC I2C Quick Write Command
[apiInstance petEciicQuickAddrPostWith:addr
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicQuickAddrPost(addr, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format

            try
            {
                // Send EC I2C Quick Write Command
                apiInstance.petEciicQuickAddrPost(addr);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicQuickAddrPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format

try {
    $api_instance->petEciicQuickAddrPost($addr);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicQuickAddrPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format

eval { 
    $api_instance->petEciicQuickAddrPost(addr => $addr);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicQuickAddrPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format

try: 
    # Send EC I2C Quick Write Command
    api_instance.pet_eciic_quick_addr_post(addr)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicQuickAddrPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required

Responses

Status: 200 - EC I2C Quick Command sent successfully

Status: 500 - An error occurred while send EC I2C Quick Write Command.


petEciicReceiveAddrGet

Command for receive byte from EC I2C


/pet/eciic/receive/{addr}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/receive/{addr}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            inline_response_200_17 result = apiInstance.petEciicReceiveAddrGet(addr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicReceiveAddrGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        try {
            inline_response_200_17 result = apiInstance.petEciicReceiveAddrGet(addr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicReceiveAddrGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format

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

// Command for receive byte from EC I2C
[apiInstance petEciicReceiveAddrGetWith:addr
              completionHandler: ^(inline_response_200_17 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petEciicReceiveAddrGet(addr, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format

            try
            {
                // Command for receive byte from EC I2C
                inline_response_200_17 result = apiInstance.petEciicReceiveAddrGet(addr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicReceiveAddrGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format

try {
    $result = $api_instance->petEciicReceiveAddrGet($addr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicReceiveAddrGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format

eval { 
    my $result = $api_instance->petEciicReceiveAddrGet(addr => $addr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicReceiveAddrGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format

try: 
    # Command for receive byte from EC I2C
    api_response = api_instance.pet_eciic_receive_addr_get(addr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicReceiveAddrGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required

Responses

Status: 200 - Byte received successfully

Status: 500 - An error occurred while send EC I2C received byte Command.


petEciicSendAddrDataPost

Command for send byte to EC I2C Device


/pet/eciic/send/{addr}/{data}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/send/{addr}/{data}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petEciicSendAddrDataPost(addr, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicSendAddrDataPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petEciicSendAddrDataPost(addr, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicSendAddrDataPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *data = data_example; // Data parameter in hexadecimal format

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

// Command for send byte to EC I2C Device
[apiInstance petEciicSendAddrDataPostWith:addr
    data:data
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var data = data_example; // {{String}} Data parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicSendAddrDataPost(addr, data, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var data = data_example;  // String | Data parameter in hexadecimal format

            try
            {
                // Command for send byte to EC I2C Device
                apiInstance.petEciicSendAddrDataPost(addr, data);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicSendAddrDataPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$data = data_example; // String | Data parameter in hexadecimal format

try {
    $api_instance->petEciicSendAddrDataPost($addr, $data);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicSendAddrDataPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $data = data_example; # String | Data parameter in hexadecimal format

eval { 
    $api_instance->petEciicSendAddrDataPost(addr => $addr, data => $data);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicSendAddrDataPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format
data = data_example # String | Data parameter in hexadecimal format

try: 
    # Command for send byte to EC I2C Device
    api_instance.pet_eciic_send_addr_data_post(addr, data)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicSendAddrDataPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
data*
String
Data parameter in hexadecimal format
Required

Responses

Status: 200 - Byte sent successfully

Status: 500 - An error occurred while send EC I2C send byte Command.


petEciicWordAddrOffsetLengthGet

Send EC I2C Word Read Command


/pet/eciic/word/{addr}/{offset}/{length}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/eciic/word/{addr}/{offset}/{length}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to read
        try {
            offset_length_body result = apiInstance.petEciicWordAddrOffsetLengthGet(addr, offset, length);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicWordAddrOffsetLengthGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to read
        try {
            offset_length_body result = apiInstance.petEciicWordAddrOffsetLengthGet(addr, offset, length);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicWordAddrOffsetLengthGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *offset = offset_example; // Offset parameter in hexadecimal format
Integer *length = 56; // Number of bytes to read

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

// Send EC I2C Word Read Command
[apiInstance petEciicWordAddrOffsetLengthGetWith:addr
    offset:offset
    length:length
              completionHandler: ^(offset_length_body output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var offset = offset_example; // {{String}} Offset parameter in hexadecimal format
var length = 56; // {{Integer}} Number of bytes to read

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petEciicWordAddrOffsetLengthGet(addr, offset, length, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var offset = offset_example;  // String | Offset parameter in hexadecimal format
            var length = 56;  // Integer | Number of bytes to read

            try
            {
                // Send EC I2C Word Read Command
                offset_length_body result = apiInstance.petEciicWordAddrOffsetLengthGet(addr, offset, length);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicWordAddrOffsetLengthGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$offset = offset_example; // String | Offset parameter in hexadecimal format
$length = 56; // Integer | Number of bytes to read

try {
    $result = $api_instance->petEciicWordAddrOffsetLengthGet($addr, $offset, $length);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $offset = offset_example; # String | Offset parameter in hexadecimal format
my $length = 56; # Integer | Number of bytes to read

eval { 
    my $result = $api_instance->petEciicWordAddrOffsetLengthGet(addr => $addr, offset => $offset, length => $length);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
addr = addr_example # String | Address parameter in hexadecimal format
offset = offset_example # String | Offset parameter in hexadecimal format
length = 56 # Integer | Number of bytes to read

try: 
    # Send EC I2C Word Read Command
    api_response = api_instance.pet_eciic_word_addr_offset_length_get(addr, offset, length)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
offset*
String
Offset parameter in hexadecimal format
Required
length*
Integer
Number of bytes to read
Required

Responses

Status: 200 - Word read successfully

Status: 500 - An error occurred while send EC I2C word read Command.


petEciicWordAddrOffsetLengthPost

Send EC I2C Word Write Command


/pet/eciic/word/{addr}/{offset}/{length}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/eciic/word/{addr}/{offset}/{length}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ECI2CApi;

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

public class ECI2CApiExample {

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

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

        ECI2CApi apiInstance = new ECI2CApi();
        Offset_length_body_1 body = ; // Offset_length_body_1 | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petEciicWordAddrOffsetLengthPost(body, addr, offset, length);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicWordAddrOffsetLengthPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ECI2CApi;

public class ECI2CApiExample {

    public static void main(String[] args) {
        ECI2CApi apiInstance = new ECI2CApi();
        Offset_length_body_1 body = ; // Offset_length_body_1 | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String offset = offset_example; // String | Offset parameter in hexadecimal format
        Integer length = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petEciicWordAddrOffsetLengthPost(body, addr, offset, length);
        } catch (ApiException e) {
            System.err.println("Exception when calling ECI2CApi#petEciicWordAddrOffsetLengthPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Offset_length_body_1 *body = ; // 
String *addr = addr_example; // Address parameter in hexadecimal format
String *offset = offset_example; // Offset parameter in hexadecimal format
Integer *length = 56; // Number of bytes to write

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

// Send EC I2C Word Write Command
[apiInstance petEciicWordAddrOffsetLengthPostWith:body
    addr:addr
    offset:offset
    length:length
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.ECI2CApi()
var body = ; // {{Offset_length_body_1}} 
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var offset = offset_example; // {{String}} Offset parameter in hexadecimal format
var length = 56; // {{Integer}} Number of bytes to write

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petEciicWordAddrOffsetLengthPost(bodyaddroffsetlength, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new ECI2CApi();
            var body = new Offset_length_body_1(); // Offset_length_body_1 | 
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var offset = offset_example;  // String | Offset parameter in hexadecimal format
            var length = 56;  // Integer | Number of bytes to write

            try
            {
                // Send EC I2C Word Write Command
                apiInstance.petEciicWordAddrOffsetLengthPost(body, addr, offset, length);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ECI2CApi.petEciicWordAddrOffsetLengthPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiECI2CApi();
$body = ; // Offset_length_body_1 | 
$addr = addr_example; // String | Address parameter in hexadecimal format
$offset = offset_example; // String | Offset parameter in hexadecimal format
$length = 56; // Integer | Number of bytes to write

try {
    $api_instance->petEciicWordAddrOffsetLengthPost($body, $addr, $offset, $length);
} catch (Exception $e) {
    echo 'Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ECI2CApi;

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

my $api_instance = WWW::SwaggerClient::ECI2CApi->new();
my $body = WWW::SwaggerClient::Object::Offset_length_body_1->new(); # Offset_length_body_1 | 
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $offset = offset_example; # String | Offset parameter in hexadecimal format
my $length = 56; # Integer | Number of bytes to write

eval { 
    $api_instance->petEciicWordAddrOffsetLengthPost(body => $body, addr => $addr, offset => $offset, length => $length);
};
if ($@) {
    warn "Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.ECI2CApi()
body =  # Offset_length_body_1 | 
addr = addr_example # String | Address parameter in hexadecimal format
offset = offset_example # String | Offset parameter in hexadecimal format
length = 56 # Integer | Number of bytes to write

try: 
    # Send EC I2C Word Write Command
    api_instance.pet_eciic_word_addr_offset_length_post(body, addr, offset, length)
except ApiException as e:
    print("Exception when calling ECI2CApi->petEciicWordAddrOffsetLengthPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
offset*
String
Offset parameter in hexadecimal format
Required
length*
Integer
Number of bytes to write
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Word sent successfully

Status: 500 - An error occurred while send EC I2C word write Command.


FirmwareUpdate

petFirmwareDeleteTypePost

Delete uploaded firmware binary file


/pet/firmware/delete/{type}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/firmware/delete/{type}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        String type = type_example; // String | 
        try {
            apiInstance.petFirmwareDeleteTypePost(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareDeleteTypePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        String type = type_example; // String | 
        try {
            apiInstance.petFirmwareDeleteTypePost(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareDeleteTypePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *type = type_example; // 

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

// Delete uploaded firmware binary file
[apiInstance petFirmwareDeleteTypePostWith:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var type = type_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petFirmwareDeleteTypePost(type, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();
            var type = type_example;  // String | 

            try
            {
                // Delete uploaded firmware binary file
                apiInstance.petFirmwareDeleteTypePost(type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareDeleteTypePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();
$type = type_example; // String | 

try {
    $api_instance->petFirmwareDeleteTypePost($type);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareDeleteTypePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

my $api_instance = WWW::SwaggerClient::FirmwareUpdateApi->new();
my $type = type_example; # String | 

eval { 
    $api_instance->petFirmwareDeleteTypePost(type => $type);
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareDeleteTypePost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.FirmwareUpdateApi()
type = type_example # String | 

try: 
    # Delete uploaded firmware binary file
    api_instance.pet_firmware_delete_type_post(type)
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareDeleteTypePost: %s\n" % e)

Parameters

Path parameters
Name Description
type*
String
Required

Responses

Status: 200 - File upload success.

Status: 410 - Target file was gone. Cannot delete it.

Status: 500 - An error occurred while upload file.


petFirmwareGet

Returns firmware update status.


/pet/firmware

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/firmware"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        try {
            inline_response_200_20 result = apiInstance.petFirmwareGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        try {
            inline_response_200_20 result = apiInstance.petFirmwareGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Returns firmware update status.
[apiInstance petFirmwareGetWithCompletionHandler: 
              ^(inline_response_200_20 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petFirmwareGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();

            try
            {
                // Returns firmware update status.
                inline_response_200_20 result = apiInstance.petFirmwareGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();

try {
    $result = $api_instance->petFirmwareGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

my $api_instance = WWW::SwaggerClient::FirmwareUpdateApi->new();

eval { 
    my $result = $api_instance->petFirmwareGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.FirmwareUpdateApi()

try: 
    # Returns firmware update status.
    api_response = api_instance.pet_firmware_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareGet: %s\n" % e)

Parameters

Responses

Status: 200 - Firmware update status retrieved successfully.

Status: 500 - An error occurred while get firmware update status.


petFirmwareTypeGet

Returns firmware update status.


/pet/firmware/{type}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/firmware/{type}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        String type = type_example; // String | 
        try {
            FWStatus result = apiInstance.petFirmwareTypeGet(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareTypeGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        String type = type_example; // String | 
        try {
            FWStatus result = apiInstance.petFirmwareTypeGet(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareTypeGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *type = type_example; // 

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

// Returns firmware update status.
[apiInstance petFirmwareTypeGetWith:type
              completionHandler: ^(FWStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var type = type_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petFirmwareTypeGet(type, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();
            var type = type_example;  // String | 

            try
            {
                // Returns firmware update status.
                FWStatus result = apiInstance.petFirmwareTypeGet(type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareTypeGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();
$type = type_example; // String | 

try {
    $result = $api_instance->petFirmwareTypeGet($type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareTypeGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

my $api_instance = WWW::SwaggerClient::FirmwareUpdateApi->new();
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->petFirmwareTypeGet(type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareTypeGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.FirmwareUpdateApi()
type = type_example # String | 

try: 
    # Returns firmware update status.
    api_response = api_instance.pet_firmware_type_get(type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareTypeGet: %s\n" % e)

Parameters

Path parameters
Name Description
type*
String
Required

Responses

Status: 200 - Firmware update status retrieved successfully.

Status: 500 - An error occurred while get firmware update status.


petFirmwareUpdateBiosPost

update firmware


/pet/firmware/update/bios

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/firmware/update/bios"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        Update_bios_body body = ; // Update_bios_body | 
        try {
            apiInstance.petFirmwareUpdateBiosPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUpdateBiosPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        Update_bios_body body = ; // Update_bios_body | 
        try {
            apiInstance.petFirmwareUpdateBiosPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUpdateBiosPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Update_bios_body *body = ; // 

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

// update firmware
[apiInstance petFirmwareUpdateBiosPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var body = ; // {{Update_bios_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petFirmwareUpdateBiosPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();
            var body = new Update_bios_body(); // Update_bios_body | 

            try
            {
                // update firmware
                apiInstance.petFirmwareUpdateBiosPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareUpdateBiosPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();
$body = ; // Update_bios_body | 

try {
    $api_instance->petFirmwareUpdateBiosPost($body);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareUpdateBiosPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

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

eval { 
    $api_instance->petFirmwareUpdateBiosPost(body => $body);
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareUpdateBiosPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # update firmware
    api_instance.pet_firmware_update_bios_post(body)
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareUpdateBiosPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - firmware update started

Status: 500 - An error occurred while start firmware update.


petFirmwareUpdateEcPost

update firmware


/pet/firmware/update/ec

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/firmware/update/ec"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        try {
            apiInstance.petFirmwareUpdateEcPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUpdateEcPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        try {
            apiInstance.petFirmwareUpdateEcPost();
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUpdateEcPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// update firmware
[apiInstance petFirmwareUpdateEcPostWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petFirmwareUpdateEcPost(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();

            try
            {
                // update firmware
                apiInstance.petFirmwareUpdateEcPost();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareUpdateEcPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();

try {
    $api_instance->petFirmwareUpdateEcPost();
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareUpdateEcPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

my $api_instance = WWW::SwaggerClient::FirmwareUpdateApi->new();

eval { 
    $api_instance->petFirmwareUpdateEcPost();
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareUpdateEcPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.FirmwareUpdateApi()

try: 
    # update firmware
    api_instance.pet_firmware_update_ec_post()
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareUpdateEcPost: %s\n" % e)

Parameters

Responses

Status: 200 - firmware update started

Status: 500 - An error occurred while start firmware update.


petFirmwareUploadTypePost

upload firmware binary file


/pet/firmware/upload/{type}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"{server}/pw/v1/pet/firmware/upload/{type}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FirmwareUpdateApi;

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

public class FirmwareUpdateApiExample {

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

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

        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        byte[] binfile = binfile_example; // byte[] | 
        String version = version_example; // String | 
        String md5sum = md5sum_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.petFirmwareUploadTypePost(binfile, version, md5sum, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUploadTypePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.FirmwareUpdateApi;

public class FirmwareUpdateApiExample {

    public static void main(String[] args) {
        FirmwareUpdateApi apiInstance = new FirmwareUpdateApi();
        byte[] binfile = binfile_example; // byte[] | 
        String version = version_example; // String | 
        String md5sum = md5sum_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.petFirmwareUploadTypePost(binfile, version, md5sum, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling FirmwareUpdateApi#petFirmwareUploadTypePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
byte[] *binfile = binfile_example; // 
String *version = version_example; // 
String *md5sum = md5sum_example; // 
String *type = type_example; // 

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

// upload firmware binary file
[apiInstance petFirmwareUploadTypePostWith:binfile
    version:version
    md5sum:md5sum
    type:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.FirmwareUpdateApi()
var binfile = binfile_example; // {{byte[]}} 
var version = version_example; // {{String}} 
var md5sum = md5sum_example; // {{String}} 
var type = type_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petFirmwareUploadTypePost(binfileversionmd5sumtype, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new FirmwareUpdateApi();
            var binfile = binfile_example;  // byte[] | 
            var version = version_example;  // String | 
            var md5sum = md5sum_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // upload firmware binary file
                apiInstance.petFirmwareUploadTypePost(binfile, version, md5sum, type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FirmwareUpdateApi.petFirmwareUploadTypePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiFirmwareUpdateApi();
$binfile = binfile_example; // byte[] | 
$version = version_example; // String | 
$md5sum = md5sum_example; // String | 
$type = type_example; // String | 

try {
    $api_instance->petFirmwareUploadTypePost($binfile, $version, $md5sum, $type);
} catch (Exception $e) {
    echo 'Exception when calling FirmwareUpdateApi->petFirmwareUploadTypePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FirmwareUpdateApi;

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

my $api_instance = WWW::SwaggerClient::FirmwareUpdateApi->new();
my $binfile = binfile_example; # byte[] | 
my $version = version_example; # String | 
my $md5sum = md5sum_example; # String | 
my $type = type_example; # String | 

eval { 
    $api_instance->petFirmwareUploadTypePost(binfile => $binfile, version => $version, md5sum => $md5sum, type => $type);
};
if ($@) {
    warn "Exception when calling FirmwareUpdateApi->petFirmwareUploadTypePost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.FirmwareUpdateApi()
binfile = binfile_example # byte[] | 
version = version_example # String | 
md5sum = md5sum_example # String | 
type = type_example # String | 

try: 
    # upload firmware binary file
    api_instance.pet_firmware_upload_type_post(binfile, version, md5sum, type)
except ApiException as e:
    print("Exception when calling FirmwareUpdateApi->petFirmwareUploadTypePost: %s\n" % e)

Parameters

Path parameters
Name Description
type*
String
Required
Form parameters
Name Description
binfile*
byte[] (binary)
Required
version*
String
Required
md5sum*
String
Required

Responses

Status: 200 - Delete file success.

Status: 409 - Conflict due to file exists.

Status: 500 - An error occurred while upload file.


GPIO

petGpioGet

Get GPIO Settings

Retrieve the current state of all GPIO pins.


/pet/gpio

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/gpio"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GPIOApi;

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

public class GPIOApiExample {

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

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

        GPIOApi apiInstance = new GPIOApi();
        try {
            GPIOSettings result = apiInstance.petGpioGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GPIOApi;

public class GPIOApiExample {

    public static void main(String[] args) {
        GPIOApi apiInstance = new GPIOApi();
        try {
            GPIOSettings result = apiInstance.petGpioGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Get GPIO Settings
[apiInstance petGpioGetWithCompletionHandler: 
              ^(GPIOSettings output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.GPIOApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petGpioGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new GPIOApi();

            try
            {
                // Get GPIO Settings
                GPIOSettings result = apiInstance.petGpioGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GPIOApi.petGpioGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiGPIOApi();

try {
    $result = $api_instance->petGpioGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GPIOApi->petGpioGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GPIOApi;

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

my $api_instance = WWW::SwaggerClient::GPIOApi->new();

eval { 
    my $result = $api_instance->petGpioGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GPIOApi->petGpioGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.GPIOApi()

try: 
    # Get GPIO Settings
    api_response = api_instance.pet_gpio_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GPIOApi->petGpioGet: %s\n" % e)

Parameters

Responses

Status: 200 - Successful response with current GPIO settings.

Status: 400 - Invalid request body format

Status: 500 - An error occurred while retrieving GPIO data.


petGpioSetGet

Get the direction and value of GPIO pins in a set


/pet/gpio/{set}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/gpio/{set}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GPIOApi;

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

public class GPIOApiExample {

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

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

        GPIOApi apiInstance = new GPIOApi();
        Integer set = 56; // Integer | The set of GPIO pins
        try {
            inline_response_200_14 result = apiInstance.petGpioSetGet(set);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GPIOApi;

public class GPIOApiExample {

    public static void main(String[] args) {
        GPIOApi apiInstance = new GPIOApi();
        Integer set = 56; // Integer | The set of GPIO pins
        try {
            inline_response_200_14 result = apiInstance.petGpioSetGet(set);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Integer *set = 56; // The set of GPIO pins

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

// Get the direction and value of GPIO pins in a set
[apiInstance petGpioSetGetWith:set
              completionHandler: ^(inline_response_200_14 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.GPIOApi()
var set = 56; // {{Integer}} The set of GPIO pins

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petGpioSetGet(set, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new GPIOApi();
            var set = 56;  // Integer | The set of GPIO pins

            try
            {
                // Get the direction and value of GPIO pins in a set
                inline_response_200_14 result = apiInstance.petGpioSetGet(set);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GPIOApi.petGpioSetGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiGPIOApi();
$set = 56; // Integer | The set of GPIO pins

try {
    $result = $api_instance->petGpioSetGet($set);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GPIOApi->petGpioSetGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GPIOApi;

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

my $api_instance = WWW::SwaggerClient::GPIOApi->new();
my $set = 56; # Integer | The set of GPIO pins

eval { 
    my $result = $api_instance->petGpioSetGet(set => $set);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GPIOApi->petGpioSetGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.GPIOApi()
set = 56 # Integer | The set of GPIO pins

try: 
    # Get the direction and value of GPIO pins in a set
    api_response = api_instance.pet_gpio_set_get(set)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GPIOApi->petGpioSetGet: %s\n" % e)

Parameters

Path parameters
Name Description
set*
Integer
The set of GPIO pins
Required

Responses

Status: 200 - OK

Status: 500 - An error occurred while retrieving GPIO data.


petGpioSetPinGet

Get the direction of a GPIO pin in a set


/pet/gpio/{set}/{pin}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/gpio/{set}/{pin}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GPIOApi;

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

public class GPIOApiExample {

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

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

        GPIOApi apiInstance = new GPIOApi();
        Integer set = 56; // Integer | The set of GPIO pins
        Integer pin = 56; // Integer | The GPIO pin number
        try {
            PinOne result = apiInstance.petGpioSetPinGet(set, pin);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPinGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GPIOApi;

public class GPIOApiExample {

    public static void main(String[] args) {
        GPIOApi apiInstance = new GPIOApi();
        Integer set = 56; // Integer | The set of GPIO pins
        Integer pin = 56; // Integer | The GPIO pin number
        try {
            PinOne result = apiInstance.petGpioSetPinGet(set, pin);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPinGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Integer *set = 56; // The set of GPIO pins
Integer *pin = 56; // The GPIO pin number

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

// Get the direction of a GPIO pin in a set
[apiInstance petGpioSetPinGetWith:set
    pin:pin
              completionHandler: ^(PinOne output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.GPIOApi()
var set = 56; // {{Integer}} The set of GPIO pins
var pin = 56; // {{Integer}} The GPIO pin number

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petGpioSetPinGet(set, pin, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new GPIOApi();
            var set = 56;  // Integer | The set of GPIO pins
            var pin = 56;  // Integer | The GPIO pin number

            try
            {
                // Get the direction of a GPIO pin in a set
                PinOne result = apiInstance.petGpioSetPinGet(set, pin);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GPIOApi.petGpioSetPinGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiGPIOApi();
$set = 56; // Integer | The set of GPIO pins
$pin = 56; // Integer | The GPIO pin number

try {
    $result = $api_instance->petGpioSetPinGet($set, $pin);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GPIOApi->petGpioSetPinGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GPIOApi;

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

my $api_instance = WWW::SwaggerClient::GPIOApi->new();
my $set = 56; # Integer | The set of GPIO pins
my $pin = 56; # Integer | The GPIO pin number

eval { 
    my $result = $api_instance->petGpioSetPinGet(set => $set, pin => $pin);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GPIOApi->petGpioSetPinGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.GPIOApi()
set = 56 # Integer | The set of GPIO pins
pin = 56 # Integer | The GPIO pin number

try: 
    # Get the direction of a GPIO pin in a set
    api_response = api_instance.pet_gpio_set_pin_get(set, pin)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GPIOApi->petGpioSetPinGet: %s\n" % e)

Parameters

Path parameters
Name Description
set*
Integer
The set of GPIO pins
Required
pin*
Integer
The GPIO pin number
Required

Responses

Status: 200 - OK

Status: 500 - An error occurred while retrieving GPIO data.


petGpioSetPinPost

Set the direction of a GPIO pin in a set


/pet/gpio/{set}/{pin}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/gpio/{set}/{pin}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GPIOApi;

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

public class GPIOApiExample {

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

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

        GPIOApi apiInstance = new GPIOApi();
        PinOne body = ; // PinOne | 
        Integer set = 56; // Integer | The set of GPIO pins
        Integer pin = 56; // Integer | The GPIO pin number
        try {
            apiInstance.petGpioSetPinPost(body, set, pin);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPinPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GPIOApi;

public class GPIOApiExample {

    public static void main(String[] args) {
        GPIOApi apiInstance = new GPIOApi();
        PinOne body = ; // PinOne | 
        Integer set = 56; // Integer | The set of GPIO pins
        Integer pin = 56; // Integer | The GPIO pin number
        try {
            apiInstance.petGpioSetPinPost(body, set, pin);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPinPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
PinOne *body = ; // 
Integer *set = 56; // The set of GPIO pins
Integer *pin = 56; // The GPIO pin number

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

// Set the direction of a GPIO pin in a set
[apiInstance petGpioSetPinPostWith:body
    set:set
    pin:pin
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.GPIOApi()
var body = ; // {{PinOne}} 
var set = 56; // {{Integer}} The set of GPIO pins
var pin = 56; // {{Integer}} The GPIO pin number

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petGpioSetPinPost(bodysetpin, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new GPIOApi();
            var body = new PinOne(); // PinOne | 
            var set = 56;  // Integer | The set of GPIO pins
            var pin = 56;  // Integer | The GPIO pin number

            try
            {
                // Set the direction of a GPIO pin in a set
                apiInstance.petGpioSetPinPost(body, set, pin);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GPIOApi.petGpioSetPinPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiGPIOApi();
$body = ; // PinOne | 
$set = 56; // Integer | The set of GPIO pins
$pin = 56; // Integer | The GPIO pin number

try {
    $api_instance->petGpioSetPinPost($body, $set, $pin);
} catch (Exception $e) {
    echo 'Exception when calling GPIOApi->petGpioSetPinPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GPIOApi;

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

my $api_instance = WWW::SwaggerClient::GPIOApi->new();
my $body = WWW::SwaggerClient::Object::PinOne->new(); # PinOne | 
my $set = 56; # Integer | The set of GPIO pins
my $pin = 56; # Integer | The GPIO pin number

eval { 
    $api_instance->petGpioSetPinPost(body => $body, set => $set, pin => $pin);
};
if ($@) {
    warn "Exception when calling GPIOApi->petGpioSetPinPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.GPIOApi()
body =  # PinOne | 
set = 56 # Integer | The set of GPIO pins
pin = 56 # Integer | The GPIO pin number

try: 
    # Set the direction of a GPIO pin in a set
    api_instance.pet_gpio_set_pin_post(body, set, pin)
except ApiException as e:
    print("Exception when calling GPIOApi->petGpioSetPinPost: %s\n" % e)

Parameters

Path parameters
Name Description
set*
Integer
The set of GPIO pins
Required
pin*
Integer
The GPIO pin number
Required
Body parameters
Name Description
body *

Responses

Status: 200 - The direction of the specified pin was successfully set

Status: 400 - Invalid request body format

Status: 500 - An error occurred while set direction.


petGpioSetPost

Set the direction and/or value of some GPIO pins in a set


/pet/gpio/{set}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/gpio/{set}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GPIOApi;

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

public class GPIOApiExample {

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

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

        GPIOApi apiInstance = new GPIOApi();
        Gpio_set_body body = ; // Gpio_set_body | 
        Integer set = 56; // Integer | The set of GPIO pins
        try {
            apiInstance.petGpioSetPost(body, set);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.GPIOApi;

public class GPIOApiExample {

    public static void main(String[] args) {
        GPIOApi apiInstance = new GPIOApi();
        Gpio_set_body body = ; // Gpio_set_body | 
        Integer set = 56; // Integer | The set of GPIO pins
        try {
            apiInstance.petGpioSetPost(body, set);
        } catch (ApiException e) {
            System.err.println("Exception when calling GPIOApi#petGpioSetPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Gpio_set_body *body = ; // 
Integer *set = 56; // The set of GPIO pins

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

// Set the direction and/or value of some GPIO pins in a set
[apiInstance petGpioSetPostWith:body
    set:set
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.GPIOApi()
var body = ; // {{Gpio_set_body}} 
var set = 56; // {{Integer}} The set of GPIO pins

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petGpioSetPost(bodyset, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new GPIOApi();
            var body = new Gpio_set_body(); // Gpio_set_body | 
            var set = 56;  // Integer | The set of GPIO pins

            try
            {
                // Set the direction and/or value of some GPIO pins in a set
                apiInstance.petGpioSetPost(body, set);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GPIOApi.petGpioSetPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiGPIOApi();
$body = ; // Gpio_set_body | 
$set = 56; // Integer | The set of GPIO pins

try {
    $api_instance->petGpioSetPost($body, $set);
} catch (Exception $e) {
    echo 'Exception when calling GPIOApi->petGpioSetPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GPIOApi;

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

my $api_instance = WWW::SwaggerClient::GPIOApi->new();
my $body = WWW::SwaggerClient::Object::Gpio_set_body->new(); # Gpio_set_body | 
my $set = 56; # Integer | The set of GPIO pins

eval { 
    $api_instance->petGpioSetPost(body => $body, set => $set);
};
if ($@) {
    warn "Exception when calling GPIOApi->petGpioSetPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.GPIOApi()
body =  # Gpio_set_body | 
set = 56 # Integer | The set of GPIO pins

try: 
    # Set the direction and/or value of some GPIO pins in a set
    api_instance.pet_gpio_set_post(body, set)
except ApiException as e:
    print("Exception when calling GPIOApi->petGpioSetPost: %s\n" % e)

Parameters

Path parameters
Name Description
set*
Integer
The set of GPIO pins
Required
Body parameters
Name Description
body *

Responses

Status: 200 - The direction of the specified pin was successfully set

Status: 400 - Invalid request body format

Status: 500 - An error occurred while set direction.


HardwareMonitor

petHwmFanGet

Returns fan pwm.


/pet/hwm/fan

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/fan"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_11 result = apiInstance.petHwmFanGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_11 result = apiInstance.petHwmFanGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Returns fan pwm.
[apiInstance petHwmFanGetWithCompletionHandler: 
              ^(inline_response_200_11 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmFanGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();

            try
            {
                // Returns fan pwm.
                inline_response_200_11 result = apiInstance.petHwmFanGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmFanGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();

try {
    $result = $api_instance->petHwmFanGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmFanGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();

eval { 
    my $result = $api_instance->petHwmFanGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmFanGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()

try: 
    # Returns fan pwm.
    api_response = api_instance.pet_hwm_fan_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmFanGet: %s\n" % e)

Parameters

Responses

Status: 200 - Fan PWM retrieved successfully.

Status: 500 - An error occurred while retrieving fan pwm.


petHwmFanSmartIdxGet

Get the smart config of the specified fan


/pet/hwm/fan/smart/{idx}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/fan/smart/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_13 result = apiInstance.petHwmFanSmartIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSmartIdxGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_13 result = apiInstance.petHwmFanSmartIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSmartIdxGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *idx = idx_example; // 

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

// Get the smart config of the specified fan
[apiInstance petHwmFanSmartIdxGetWith:idx
              completionHandler: ^(inline_response_200_13 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmFanSmartIdxGet(idx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var idx = idx_example;  // String | 

            try
            {
                // Get the smart config of the specified fan
                inline_response_200_13 result = apiInstance.petHwmFanSmartIdxGet(idx);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmFanSmartIdxGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$idx = idx_example; // String | 

try {
    $result = $api_instance->petHwmFanSmartIdxGet($idx);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmFanSmartIdxGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $idx = idx_example; # String | 

eval { 
    my $result = $api_instance->petHwmFanSmartIdxGet(idx => $idx);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmFanSmartIdxGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
idx = idx_example # String | 

try: 
    # Get the smart config of the specified fan
    api_response = api_instance.pet_hwm_fan_smart_idx_get(idx)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmFanSmartIdxGet: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required

Responses

Status: 200 - Smart Fan data retrieved successfully.

Status: 500 - An error occurred while retrieving smart fan data.


petHwmFanSmartIdxPost

Set the smart config of the specified fan


/pet/hwm/fan/smart/{idx}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/hwm/fan/smart/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        Smart_idx_body body = ; // Smart_idx_body | 
        String idx = idx_example; // String | 
        try {
            apiInstance.petHwmFanSmartIdxPost(body, idx);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSmartIdxPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        Smart_idx_body body = ; // Smart_idx_body | 
        String idx = idx_example; // String | 
        try {
            apiInstance.petHwmFanSmartIdxPost(body, idx);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSmartIdxPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Smart_idx_body *body = ; // 
String *idx = idx_example; // 

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

// Set the smart config of the specified fan
[apiInstance petHwmFanSmartIdxPostWith:body
    idx:idx
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var body = ; // {{Smart_idx_body}} 
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petHwmFanSmartIdxPost(bodyidx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var body = new Smart_idx_body(); // Smart_idx_body | 
            var idx = idx_example;  // String | 

            try
            {
                // Set the smart config of the specified fan
                apiInstance.petHwmFanSmartIdxPost(body, idx);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmFanSmartIdxPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$body = ; // Smart_idx_body | 
$idx = idx_example; // String | 

try {
    $api_instance->petHwmFanSmartIdxPost($body, $idx);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmFanSmartIdxPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $body = WWW::SwaggerClient::Object::Smart_idx_body->new(); # Smart_idx_body | 
my $idx = idx_example; # String | 

eval { 
    $api_instance->petHwmFanSmartIdxPost(body => $body, idx => $idx);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmFanSmartIdxPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
body =  # Smart_idx_body | 
idx = idx_example # String | 

try: 
    # Set the smart config of the specified fan
    api_instance.pet_hwm_fan_smart_idx_post(body, idx)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmFanSmartIdxPost: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - The Smart Fan data was successfully set

Status: 400 - Invalid request body format

Status: 500 - An error occurred while set Smart Fan data


petHwmFanSpeedIdxGet

Get the pwm of the specified fan


/pet/hwm/fan/speed/{idx}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/fan/speed/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_12 result = apiInstance.petHwmFanSpeedIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSpeedIdxGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_12 result = apiInstance.petHwmFanSpeedIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSpeedIdxGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *idx = idx_example; // 

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

// Get the pwm of the specified fan
[apiInstance petHwmFanSpeedIdxGetWith:idx
              completionHandler: ^(inline_response_200_12 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmFanSpeedIdxGet(idx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var idx = idx_example;  // String | 

            try
            {
                // Get the pwm of the specified fan
                inline_response_200_12 result = apiInstance.petHwmFanSpeedIdxGet(idx);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmFanSpeedIdxGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$idx = idx_example; // String | 

try {
    $result = $api_instance->petHwmFanSpeedIdxGet($idx);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $idx = idx_example; # String | 

eval { 
    my $result = $api_instance->petHwmFanSpeedIdxGet(idx => $idx);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
idx = idx_example # String | 

try: 
    # Get the pwm of the specified fan
    api_response = api_instance.pet_hwm_fan_speed_idx_get(idx)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxGet: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required

Responses

Status: 200 - Fan data retrieved successfully.

Status: 500 - An error occurred while retrieving fan data.


petHwmFanSpeedIdxPost

Set the ratio of the specified fan


/pet/hwm/fan/speed/{idx}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/hwm/fan/speed/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        Speed_idx_body body = ; // Speed_idx_body | 
        String idx = idx_example; // String | 
        try {
            apiInstance.petHwmFanSpeedIdxPost(body, idx);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSpeedIdxPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        Speed_idx_body body = ; // Speed_idx_body | 
        String idx = idx_example; // String | 
        try {
            apiInstance.petHwmFanSpeedIdxPost(body, idx);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmFanSpeedIdxPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Speed_idx_body *body = ; // 
String *idx = idx_example; // 

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

// Set the ratio of the specified fan
[apiInstance petHwmFanSpeedIdxPostWith:body
    idx:idx
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var body = ; // {{Speed_idx_body}} 
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petHwmFanSpeedIdxPost(bodyidx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var body = new Speed_idx_body(); // Speed_idx_body | 
            var idx = idx_example;  // String | 

            try
            {
                // Set the ratio of the specified fan
                apiInstance.petHwmFanSpeedIdxPost(body, idx);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmFanSpeedIdxPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$body = ; // Speed_idx_body | 
$idx = idx_example; // String | 

try {
    $api_instance->petHwmFanSpeedIdxPost($body, $idx);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $body = WWW::SwaggerClient::Object::Speed_idx_body->new(); # Speed_idx_body | 
my $idx = idx_example; # String | 

eval { 
    $api_instance->petHwmFanSpeedIdxPost(body => $body, idx => $idx);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
body =  # Speed_idx_body | 
idx = idx_example # String | 

try: 
    # Set the ratio of the specified fan
    api_instance.pet_hwm_fan_speed_idx_post(body, idx)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmFanSpeedIdxPost: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - The fan ratio was successfully set

Status: 400 - Invalid request body format

Status: 500 - An error occurred while set fan ratio


petHwmGet

Returns hardware monitor datas.


/pet/hwm

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_7 result = apiInstance.petHwmGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_7 result = apiInstance.petHwmGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Returns hardware monitor datas.
[apiInstance petHwmGetWithCompletionHandler: 
              ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();

            try
            {
                // Returns hardware monitor datas.
                inline_response_200_7 result = apiInstance.petHwmGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();

try {
    $result = $api_instance->petHwmGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();

eval { 
    my $result = $api_instance->petHwmGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()

try: 
    # Returns hardware monitor datas.
    api_response = api_instance.pet_hwm_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmGet: %s\n" % e)

Parameters

Responses

Status: 200 - hardware monitor datas retrieved successfully.

Status: 500 - An error occurred while retrieving temperature.


petHwmTemperatureGet

Returns temperature data for CPU, System, and PSU.


/pet/hwm/temperature

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/temperature"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_7 result = apiInstance.petHwmTemperatureGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmTemperatureGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_7 result = apiInstance.petHwmTemperatureGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmTemperatureGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Returns temperature data for CPU, System, and PSU.
[apiInstance petHwmTemperatureGetWithCompletionHandler: 
              ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmTemperatureGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();

            try
            {
                // Returns temperature data for CPU, System, and PSU.
                inline_response_200_7 result = apiInstance.petHwmTemperatureGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmTemperatureGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();

try {
    $result = $api_instance->petHwmTemperatureGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmTemperatureGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();

eval { 
    my $result = $api_instance->petHwmTemperatureGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmTemperatureGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()

try: 
    # Returns temperature data for CPU, System, and PSU.
    api_response = api_instance.pet_hwm_temperature_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmTemperatureGet: %s\n" % e)

Parameters

Responses

Status: 200 - Temperature data retrieved successfully.

Status: 500 - An error occurred while retrieving temperature.


petHwmTemperatureIdxGet

Get the temperature of the specified device


/pet/hwm/temperature/{idx}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/temperature/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_8 result = apiInstance.petHwmTemperatureIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmTemperatureIdxGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_8 result = apiInstance.petHwmTemperatureIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmTemperatureIdxGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *idx = idx_example; // 

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

// Get the temperature of the specified device
[apiInstance petHwmTemperatureIdxGetWith:idx
              completionHandler: ^(inline_response_200_8 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmTemperatureIdxGet(idx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var idx = idx_example;  // String | 

            try
            {
                // Get the temperature of the specified device
                inline_response_200_8 result = apiInstance.petHwmTemperatureIdxGet(idx);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmTemperatureIdxGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$idx = idx_example; // String | 

try {
    $result = $api_instance->petHwmTemperatureIdxGet($idx);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmTemperatureIdxGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $idx = idx_example; # String | 

eval { 
    my $result = $api_instance->petHwmTemperatureIdxGet(idx => $idx);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmTemperatureIdxGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
idx = idx_example # String | 

try: 
    # Get the temperature of the specified device
    api_response = api_instance.pet_hwm_temperature_idx_get(idx)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmTemperatureIdxGet: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required

Responses

Status: 200 - Temperature data retrieved successfully.

Status: 500 - An error occurred while retrieving temperature.


petHwmVoltageGet

Returns voltage data.


/pet/hwm/voltage

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/voltage"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_9 result = apiInstance.petHwmVoltageGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmVoltageGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        try {
            inline_response_200_9 result = apiInstance.petHwmVoltageGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmVoltageGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Returns voltage data.
[apiInstance petHwmVoltageGetWithCompletionHandler: 
              ^(inline_response_200_9 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmVoltageGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();

            try
            {
                // Returns voltage data.
                inline_response_200_9 result = apiInstance.petHwmVoltageGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmVoltageGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();

try {
    $result = $api_instance->petHwmVoltageGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmVoltageGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();

eval { 
    my $result = $api_instance->petHwmVoltageGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmVoltageGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()

try: 
    # Returns voltage data.
    api_response = api_instance.pet_hwm_voltage_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmVoltageGet: %s\n" % e)

Parameters

Responses

Status: 200 - Voltage data retrieved successfully.

Status: 500 - An error occurred while retrieving voltage data.


petHwmVoltageIdxGet

Get the temperature of the specified device


/pet/hwm/voltage/{idx}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/hwm/voltage/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HardwareMonitorApi;

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

public class HardwareMonitorApiExample {

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

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

        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_10 result = apiInstance.petHwmVoltageIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmVoltageIdxGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HardwareMonitorApi;

public class HardwareMonitorApiExample {

    public static void main(String[] args) {
        HardwareMonitorApi apiInstance = new HardwareMonitorApi();
        String idx = idx_example; // String | 
        try {
            inline_response_200_10 result = apiInstance.petHwmVoltageIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HardwareMonitorApi#petHwmVoltageIdxGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *idx = idx_example; // 

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

// Get the temperature of the specified device
[apiInstance petHwmVoltageIdxGetWith:idx
              completionHandler: ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.HardwareMonitorApi()
var idx = idx_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petHwmVoltageIdxGet(idx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new HardwareMonitorApi();
            var idx = idx_example;  // String | 

            try
            {
                // Get the temperature of the specified device
                inline_response_200_10 result = apiInstance.petHwmVoltageIdxGet(idx);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HardwareMonitorApi.petHwmVoltageIdxGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiHardwareMonitorApi();
$idx = idx_example; // String | 

try {
    $result = $api_instance->petHwmVoltageIdxGet($idx);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HardwareMonitorApi->petHwmVoltageIdxGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HardwareMonitorApi;

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

my $api_instance = WWW::SwaggerClient::HardwareMonitorApi->new();
my $idx = idx_example; # String | 

eval { 
    my $result = $api_instance->petHwmVoltageIdxGet(idx => $idx);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HardwareMonitorApi->petHwmVoltageIdxGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.HardwareMonitorApi()
idx = idx_example # String | 

try: 
    # Get the temperature of the specified device
    api_response = api_instance.pet_hwm_voltage_idx_get(idx)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HardwareMonitorApi->petHwmVoltageIdxGet: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
String
Required

Responses

Status: 200 - Voltage data retrieved successfully.

Status: 500 - An error occurred while retrieving voltage.


Logs

petLogIdxGet

Get RPET logfile


/pet/log/{idx}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: text/plain,application/json"\
"{server}/pw/v1/pet/log/{idx}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LogsApi;

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

public class LogsApiExample {

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

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

        LogsApi apiInstance = new LogsApi();
        Integer idx = 56; // Integer | The index of logfile
        try {
            byte[] result = apiInstance.petLogIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsApi#petLogIdxGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LogsApi;

public class LogsApiExample {

    public static void main(String[] args) {
        LogsApi apiInstance = new LogsApi();
        Integer idx = 56; // Integer | The index of logfile
        try {
            byte[] result = apiInstance.petLogIdxGet(idx);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogsApi#petLogIdxGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Integer *idx = 56; // The index of logfile

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

// Get RPET logfile
[apiInstance petLogIdxGetWith:idx
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.LogsApi()
var idx = 56; // {{Integer}} The index of logfile

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petLogIdxGet(idx, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new LogsApi();
            var idx = 56;  // Integer | The index of logfile

            try
            {
                // Get RPET logfile
                byte[] result = apiInstance.petLogIdxGet(idx);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LogsApi.petLogIdxGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiLogsApi();
$idx = 56; // Integer | The index of logfile

try {
    $result = $api_instance->petLogIdxGet($idx);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LogsApi->petLogIdxGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LogsApi;

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

my $api_instance = WWW::SwaggerClient::LogsApi->new();
my $idx = 56; # Integer | The index of logfile

eval { 
    my $result = $api_instance->petLogIdxGet(idx => $idx);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LogsApi->petLogIdxGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.LogsApi()
idx = 56 # Integer | The index of logfile

try: 
    # Get RPET logfile
    api_response = api_instance.pet_log_idx_get(idx)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LogsApi->petLogIdxGet: %s\n" % e)

Parameters

Path parameters
Name Description
idx*
Integer
The index of logfile
Required

Responses

Status: 200 - Get the logfile success.

Status: 404 - Logfile not found.

Status: 500 - An error occurred while get logfile


PowerControl

petPowerOffPost

Shutdown the system

send shutdown command to the system


/pet/power/off

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/power/off"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PowerControlApi;

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

public class PowerControlApiExample {

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

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

        PowerControlApi apiInstance = new PowerControlApi();
        Power_off_body body = ; // Power_off_body | 
        try {
            apiInstance.petPowerOffPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerControlApi#petPowerOffPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PowerControlApi;

public class PowerControlApiExample {

    public static void main(String[] args) {
        PowerControlApi apiInstance = new PowerControlApi();
        Power_off_body body = ; // Power_off_body | 
        try {
            apiInstance.petPowerOffPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerControlApi#petPowerOffPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Power_off_body *body = ; // 

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

// Shutdown the system
[apiInstance petPowerOffPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.PowerControlApi()
var body = ; // {{Power_off_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petPowerOffPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new PowerControlApi();
            var body = new Power_off_body(); // Power_off_body | 

            try
            {
                // Shutdown the system
                apiInstance.petPowerOffPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PowerControlApi.petPowerOffPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiPowerControlApi();
$body = ; // Power_off_body | 

try {
    $api_instance->petPowerOffPost($body);
} catch (Exception $e) {
    echo 'Exception when calling PowerControlApi->petPowerOffPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PowerControlApi;

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

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

eval { 
    $api_instance->petPowerOffPost(body => $body);
};
if ($@) {
    warn "Exception when calling PowerControlApi->petPowerOffPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Shutdown the system
    api_instance.pet_power_off_post(body)
except ApiException as e:
    print("Exception when calling PowerControlApi->petPowerOffPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Successful start reboot process.

Status: 500 - An error occurred while start reboot process.


petPowerRebootPost

Reboot the system

send reboot command to the system


/pet/power/reboot

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/power/reboot"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PowerControlApi;

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

public class PowerControlApiExample {

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

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

        PowerControlApi apiInstance = new PowerControlApi();
        Power_reboot_body body = ; // Power_reboot_body | 
        try {
            apiInstance.petPowerRebootPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerControlApi#petPowerRebootPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.PowerControlApi;

public class PowerControlApiExample {

    public static void main(String[] args) {
        PowerControlApi apiInstance = new PowerControlApi();
        Power_reboot_body body = ; // Power_reboot_body | 
        try {
            apiInstance.petPowerRebootPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PowerControlApi#petPowerRebootPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Power_reboot_body *body = ; // 

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

// Reboot the system
[apiInstance petPowerRebootPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.PowerControlApi()
var body = ; // {{Power_reboot_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petPowerRebootPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new PowerControlApi();
            var body = new Power_reboot_body(); // Power_reboot_body | 

            try
            {
                // Reboot the system
                apiInstance.petPowerRebootPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PowerControlApi.petPowerRebootPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiPowerControlApi();
$body = ; // Power_reboot_body | 

try {
    $api_instance->petPowerRebootPost($body);
} catch (Exception $e) {
    echo 'Exception when calling PowerControlApi->petPowerRebootPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PowerControlApi;

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

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

eval { 
    $api_instance->petPowerRebootPost(body => $body);
};
if ($@) {
    warn "Exception when calling PowerControlApi->petPowerRebootPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Reboot the system
    api_instance.pet_power_reboot_post(body)
except ApiException as e:
    print("Exception when calling PowerControlApi->petPowerRebootPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Successful start reboot process.

Status: 500 - An error occurred while start reboot process.


SCAN

scanScanKeyGet

Provide Basic platform information for user


/scan/{scan-key}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/scan/{scan-key}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SCANApi;

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

public class SCANApiExample {

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

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

        SCANApi apiInstance = new SCANApi();
        String scanKey = scanKey_example; // String | 
        try {
            inline_response_200 result = apiInstance.scanScanKeyGet(scanKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SCANApi#scanScanKeyGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SCANApi;

public class SCANApiExample {

    public static void main(String[] args) {
        SCANApi apiInstance = new SCANApi();
        String scanKey = scanKey_example; // String | 
        try {
            inline_response_200 result = apiInstance.scanScanKeyGet(scanKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SCANApi#scanScanKeyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *scanKey = scanKey_example; // 

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

// Provide Basic platform information for user
[apiInstance scanScanKeyGetWith:scanKey
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SCANApi()
var scanKey = scanKey_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scanScanKeyGet(scanKey, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SCANApi();
            var scanKey = scanKey_example;  // String | 

            try
            {
                // Provide Basic platform information for user
                inline_response_200 result = apiInstance.scanScanKeyGet(scanKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SCANApi.scanScanKeyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSCANApi();
$scanKey = scanKey_example; // String | 

try {
    $result = $api_instance->scanScanKeyGet($scanKey);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SCANApi->scanScanKeyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SCANApi;

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

my $api_instance = WWW::SwaggerClient::SCANApi->new();
my $scanKey = scanKey_example; # String | 

eval { 
    my $result = $api_instance->scanScanKeyGet(scanKey => $scanKey);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SCANApi->scanScanKeyGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SCANApi()
scanKey = scanKey_example # String | 

try: 
    # Provide Basic platform information for user
    api_response = api_instance.scan_scan_key_get(scanKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SCANApi->scanScanKeyGet: %s\n" % e)

Parameters

Path parameters
Name Description
scan-key*
String
Required

Responses

Status: 200 - Basic platform information retrieved successfully.

Status: 500 - An error occurred while retrieving Basic information


SMBus

petSmbusBlockAddrCmdCountGet

Send SMBus Block Read Command


/pet/smbus/block/{addr}/{cmd}/{count}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus/block/{addr}/{cmd}/{count}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        Integer count = 56; // Integer | Number of bytes to read
        try {
            inline_response_200_19 result = apiInstance.petSmbusBlockAddrCmdCountGet(addr, cmd, count);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusBlockAddrCmdCountGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        Integer count = 56; // Integer | Number of bytes to read
        try {
            inline_response_200_19 result = apiInstance.petSmbusBlockAddrCmdCountGet(addr, cmd, count);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusBlockAddrCmdCountGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format
Integer *count = 56; // Number of bytes to read

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

// Send SMBus Block Read Command
[apiInstance petSmbusBlockAddrCmdCountGetWith:addr
    cmd:cmd
    count:count
              completionHandler: ^(inline_response_200_19 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format
var count = 56; // {{Integer}} Number of bytes to read

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petSmbusBlockAddrCmdCountGet(addr, cmd, count, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format
            var count = 56;  // Integer | Number of bytes to read

            try
            {
                // Send SMBus Block Read Command
                inline_response_200_19 result = apiInstance.petSmbusBlockAddrCmdCountGet(addr, cmd, count);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusBlockAddrCmdCountGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format
$count = 56; // Integer | Number of bytes to read

try {
    $result = $api_instance->petSmbusBlockAddrCmdCountGet($addr, $cmd, $count);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusBlockAddrCmdCountGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format
my $count = 56; # Integer | Number of bytes to read

eval { 
    my $result = $api_instance->petSmbusBlockAddrCmdCountGet(addr => $addr, cmd => $cmd, count => $count);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusBlockAddrCmdCountGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format
count = 56 # Integer | Number of bytes to read

try: 
    # Send SMBus Block Read Command
    api_response = api_instance.pet_smbus_block_addr_cmd_count_get(addr, cmd, count)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusBlockAddrCmdCountGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required
count*
Integer
Number of bytes to read
Required

Responses

Status: 200 - Block read successfully

Status: 500 - An error occurred while send SMBus byte read Command.


petSmbusBlockAddrCmdCountPost

Send SMBus Block Write Command


/pet/smbus/block/{addr}/{cmd}/{count}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/smbus/block/{addr}/{cmd}/{count}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        Cmd_count_body body = ; // Cmd_count_body | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        Integer count = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petSmbusBlockAddrCmdCountPost(body, addr, cmd, count);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusBlockAddrCmdCountPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        Cmd_count_body body = ; // Cmd_count_body | 
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        Integer count = 56; // Integer | Number of bytes to write
        try {
            apiInstance.petSmbusBlockAddrCmdCountPost(body, addr, cmd, count);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusBlockAddrCmdCountPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Cmd_count_body *body = ; // 
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format
Integer *count = 56; // Number of bytes to write

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

// Send SMBus Block Write Command
[apiInstance petSmbusBlockAddrCmdCountPostWith:body
    addr:addr
    cmd:cmd
    count:count
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var body = ; // {{Cmd_count_body}} 
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format
var count = 56; // {{Integer}} Number of bytes to write

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petSmbusBlockAddrCmdCountPost(bodyaddrcmdcount, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var body = new Cmd_count_body(); // Cmd_count_body | 
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format
            var count = 56;  // Integer | Number of bytes to write

            try
            {
                // Send SMBus Block Write Command
                apiInstance.petSmbusBlockAddrCmdCountPost(body, addr, cmd, count);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusBlockAddrCmdCountPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$body = ; // Cmd_count_body | 
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format
$count = 56; // Integer | Number of bytes to write

try {
    $api_instance->petSmbusBlockAddrCmdCountPost($body, $addr, $cmd, $count);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusBlockAddrCmdCountPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $body = WWW::SwaggerClient::Object::Cmd_count_body->new(); # Cmd_count_body | 
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format
my $count = 56; # Integer | Number of bytes to write

eval { 
    $api_instance->petSmbusBlockAddrCmdCountPost(body => $body, addr => $addr, cmd => $cmd, count => $count);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusBlockAddrCmdCountPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
body =  # Cmd_count_body | 
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format
count = 56 # Integer | Number of bytes to write

try: 
    # Send SMBus Block Write Command
    api_instance.pet_smbus_block_addr_cmd_count_post(body, addr, cmd, count)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusBlockAddrCmdCountPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required
count*
Integer
Number of bytes to write
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Block write successfully

Status: 500 - An error occurred while send SMBus byte write Command.


petSmbusByteAddrCmdDataPost

Send SMBus Byte Write Command


/pet/smbus/byte/{addr}/{cmd}/{data}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus/byte/{addr}/{cmd}/{data}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petSmbusByteAddrCmdDataPost(addr, cmd, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusByteAddrCmdDataPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petSmbusByteAddrCmdDataPost(addr, cmd, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusByteAddrCmdDataPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format
String *data = data_example; // Data parameter in hexadecimal format

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

// Send SMBus Byte Write Command
[apiInstance petSmbusByteAddrCmdDataPostWith:addr
    cmd:cmd
    data:data
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format
var data = data_example; // {{String}} Data parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petSmbusByteAddrCmdDataPost(addr, cmd, data, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format
            var data = data_example;  // String | Data parameter in hexadecimal format

            try
            {
                // Send SMBus Byte Write Command
                apiInstance.petSmbusByteAddrCmdDataPost(addr, cmd, data);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusByteAddrCmdDataPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format
$data = data_example; // String | Data parameter in hexadecimal format

try {
    $api_instance->petSmbusByteAddrCmdDataPost($addr, $cmd, $data);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusByteAddrCmdDataPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format
my $data = data_example; # String | Data parameter in hexadecimal format

eval { 
    $api_instance->petSmbusByteAddrCmdDataPost(addr => $addr, cmd => $cmd, data => $data);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusByteAddrCmdDataPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format
data = data_example # String | Data parameter in hexadecimal format

try: 
    # Send SMBus Byte Write Command
    api_instance.pet_smbus_byte_addr_cmd_data_post(addr, cmd, data)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusByteAddrCmdDataPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required
data*
String
Data parameter in hexadecimal format
Required

Responses

Status: 200 - Byte sent successfully

Status: 500 - An error occurred while send SMBus byte write Command.


petSmbusByteAddrCmdGet

Send SMBus Byte Read Command


/pet/smbus/byte/{addr}/{cmd}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus/byte/{addr}/{cmd}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        try {
            inline_response_200_17 result = apiInstance.petSmbusByteAddrCmdGet(addr, cmd);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusByteAddrCmdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        try {
            inline_response_200_17 result = apiInstance.petSmbusByteAddrCmdGet(addr, cmd);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusByteAddrCmdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format

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

// Send SMBus Byte Read Command
[apiInstance petSmbusByteAddrCmdGetWith:addr
    cmd:cmd
              completionHandler: ^(inline_response_200_17 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petSmbusByteAddrCmdGet(addr, cmd, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format

            try
            {
                // Send SMBus Byte Read Command
                inline_response_200_17 result = apiInstance.petSmbusByteAddrCmdGet(addr, cmd);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusByteAddrCmdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format

try {
    $result = $api_instance->petSmbusByteAddrCmdGet($addr, $cmd);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusByteAddrCmdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format

eval { 
    my $result = $api_instance->petSmbusByteAddrCmdGet(addr => $addr, cmd => $cmd);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusByteAddrCmdGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format

try: 
    # Send SMBus Byte Read Command
    api_response = api_instance.pet_smbus_byte_addr_cmd_get(addr, cmd)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusByteAddrCmdGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required

Responses

Status: 200 - Byte read successfully

Status: 500 - An error occurred while send SMBus byte read Command.


petSmbusGet

Get SMBus Status

Retrieve the current state of SMBus.


/pet/smbus

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        try {
            inline_response_200_16 result = apiInstance.petSmbusGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        try {
            inline_response_200_16 result = apiInstance.petSmbusGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// Get SMBus Status
[apiInstance petSmbusGetWithCompletionHandler: 
              ^(inline_response_200_16 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petSmbusGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();

            try
            {
                // Get SMBus Status
                inline_response_200_16 result = apiInstance.petSmbusGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();

try {
    $result = $api_instance->petSmbusGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();

eval { 
    my $result = $api_instance->petSmbusGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()

try: 
    # Get SMBus Status
    api_response = api_instance.pet_smbus_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusGet: %s\n" % e)

Parameters

Responses

Status: 200 - Successful response with current SMBus status.

Status: 500 - An error occurred while retrieving SMBus status.


petSmbusWordAddrCmdDataPost

Send SMBus Word Write Command


/pet/smbus/word/{addr}/{cmd}/{data}

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus/word/{addr}/{cmd}/{data}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petSmbusWordAddrCmdDataPost(addr, cmd, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusWordAddrCmdDataPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        String data = data_example; // String | Data parameter in hexadecimal format
        try {
            apiInstance.petSmbusWordAddrCmdDataPost(addr, cmd, data);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusWordAddrCmdDataPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format
String *data = data_example; // Data parameter in hexadecimal format

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

// Send SMBus Word Write Command
[apiInstance petSmbusWordAddrCmdDataPostWith:addr
    cmd:cmd
    data:data
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format
var data = data_example; // {{String}} Data parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petSmbusWordAddrCmdDataPost(addr, cmd, data, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format
            var data = data_example;  // String | Data parameter in hexadecimal format

            try
            {
                // Send SMBus Word Write Command
                apiInstance.petSmbusWordAddrCmdDataPost(addr, cmd, data);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusWordAddrCmdDataPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format
$data = data_example; // String | Data parameter in hexadecimal format

try {
    $api_instance->petSmbusWordAddrCmdDataPost($addr, $cmd, $data);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusWordAddrCmdDataPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format
my $data = data_example; # String | Data parameter in hexadecimal format

eval { 
    $api_instance->petSmbusWordAddrCmdDataPost(addr => $addr, cmd => $cmd, data => $data);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusWordAddrCmdDataPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format
data = data_example # String | Data parameter in hexadecimal format

try: 
    # Send SMBus Word Write Command
    api_instance.pet_smbus_word_addr_cmd_data_post(addr, cmd, data)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusWordAddrCmdDataPost: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required
data*
String
Data parameter in hexadecimal format
Required

Responses

Status: 200 - Word sent successfully

Status: 500 - An error occurred while send SMBus word write Command.


petSmbusWordAddrCmdGet

Send SMBus Word Read Command


/pet/smbus/word/{addr}/{cmd}

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/smbus/word/{addr}/{cmd}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SMBusApi;

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

public class SMBusApiExample {

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

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

        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        try {
            inline_response_200_18 result = apiInstance.petSmbusWordAddrCmdGet(addr, cmd);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusWordAddrCmdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SMBusApi;

public class SMBusApiExample {

    public static void main(String[] args) {
        SMBusApi apiInstance = new SMBusApi();
        String addr = addr_example; // String | Address parameter in hexadecimal format
        String cmd = cmd_example; // String | Command parameter in hexadecimal format
        try {
            inline_response_200_18 result = apiInstance.petSmbusWordAddrCmdGet(addr, cmd);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SMBusApi#petSmbusWordAddrCmdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
String *addr = addr_example; // Address parameter in hexadecimal format
String *cmd = cmd_example; // Command parameter in hexadecimal format

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

// Send SMBus Word Read Command
[apiInstance petSmbusWordAddrCmdGetWith:addr
    cmd:cmd
              completionHandler: ^(inline_response_200_18 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.SMBusApi()
var addr = addr_example; // {{String}} Address parameter in hexadecimal format
var cmd = cmd_example; // {{String}} Command parameter in hexadecimal format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petSmbusWordAddrCmdGet(addr, cmd, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new SMBusApi();
            var addr = addr_example;  // String | Address parameter in hexadecimal format
            var cmd = cmd_example;  // String | Command parameter in hexadecimal format

            try
            {
                // Send SMBus Word Read Command
                inline_response_200_18 result = apiInstance.petSmbusWordAddrCmdGet(addr, cmd);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SMBusApi.petSmbusWordAddrCmdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiSMBusApi();
$addr = addr_example; // String | Address parameter in hexadecimal format
$cmd = cmd_example; // String | Command parameter in hexadecimal format

try {
    $result = $api_instance->petSmbusWordAddrCmdGet($addr, $cmd);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SMBusApi->petSmbusWordAddrCmdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SMBusApi;

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

my $api_instance = WWW::SwaggerClient::SMBusApi->new();
my $addr = addr_example; # String | Address parameter in hexadecimal format
my $cmd = cmd_example; # String | Command parameter in hexadecimal format

eval { 
    my $result = $api_instance->petSmbusWordAddrCmdGet(addr => $addr, cmd => $cmd);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SMBusApi->petSmbusWordAddrCmdGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.SMBusApi()
addr = addr_example # String | Address parameter in hexadecimal format
cmd = cmd_example # String | Command parameter in hexadecimal format

try: 
    # Send SMBus Word Read Command
    api_response = api_instance.pet_smbus_word_addr_cmd_get(addr, cmd)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SMBusApi->petSmbusWordAddrCmdGet: %s\n" % e)

Parameters

Path parameters
Name Description
addr*
String
Address parameter in hexadecimal format
Required
cmd*
String
Command parameter in hexadecimal format
Required

Responses

Status: 200 - Word read successfully

Status: 500 - An error occurred while send SMBus word read Command.


Watchdog

petWdtGet

get watchdog status


/pet/wdt

Usage and SDK Samples

curl -X GET\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
"{server}/pw/v1/pet/wdt"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WatchdogApi;

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

public class WatchdogApiExample {

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

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

        WatchdogApi apiInstance = new WatchdogApi();
        try {
            inline_response_200_15 result = apiInstance.petWdtGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WatchdogApi#petWdtGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WatchdogApi;

public class WatchdogApiExample {

    public static void main(String[] args) {
        WatchdogApi apiInstance = new WatchdogApi();
        try {
            inline_response_200_15 result = apiInstance.petWdtGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WatchdogApi#petWdtGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];

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

// get watchdog status
[apiInstance petWdtGetWithCompletionHandler: 
              ^(inline_response_200_15 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.WatchdogApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.petWdtGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new WatchdogApi();

            try
            {
                // get watchdog status
                inline_response_200_15 result = apiInstance.petWdtGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WatchdogApi.petWdtGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiWatchdogApi();

try {
    $result = $api_instance->petWdtGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling WatchdogApi->petWdtGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WatchdogApi;

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

my $api_instance = WWW::SwaggerClient::WatchdogApi->new();

eval { 
    my $result = $api_instance->petWdtGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WatchdogApi->petWdtGet: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# create an instance of the API class
api_instance = swagger_client.WatchdogApi()

try: 
    # get watchdog status
    api_response = api_instance.pet_wdt_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WatchdogApi->petWdtGet: %s\n" % e)

Parameters

Responses

Status: 200 - Watchdog config and status retrieved successfully.

Status: 500 - An error occurred while retrieving watchdog status.


petWdtPost

Set timeout and enable/disable watchdog.


/pet/wdt

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"{server}/pw/v1/pet/wdt"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.WatchdogApi;

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

public class WatchdogApiExample {

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

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

        WatchdogApi apiInstance = new WatchdogApi();
        Pet_wdt_body body = ; // Pet_wdt_body | 
        try {
            apiInstance.petWdtPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling WatchdogApi#petWdtPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.WatchdogApi;

public class WatchdogApiExample {

    public static void main(String[] args) {
        WatchdogApi apiInstance = new WatchdogApi();
        Pet_wdt_body body = ; // Pet_wdt_body | 
        try {
            apiInstance.petWdtPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling WatchdogApi#petWdtPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure API key authorization: (authentication scheme: apiKey)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];
Pet_wdt_body *body = ; // 

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

// Set timeout and enable/disable watchdog.
[apiInstance petWdtPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var RpetApi = require('rpet_api');
var defaultClient = RpetApi.ApiClient.instance;

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

var api = new RpetApi.WatchdogApi()
var body = ; // {{Pet_wdt_body}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.petWdtPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            var apiInstance = new WatchdogApi();
            var body = new Pet_wdt_body(); // Pet_wdt_body | 

            try
            {
                // Set timeout and enable/disable watchdog.
                apiInstance.petWdtPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling WatchdogApi.petWdtPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

$api_instance = new Swagger\Client\ApiWatchdogApi();
$body = ; // Pet_wdt_body | 

try {
    $api_instance->petWdtPost($body);
} catch (Exception $e) {
    echo 'Exception when calling WatchdogApi->petWdtPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::WatchdogApi;

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

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

eval { 
    $api_instance->petWdtPost(body => $body);
};
if ($@) {
    warn "Exception when calling WatchdogApi->petWdtPost: $@\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: apiKey
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

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

try: 
    # Set timeout and enable/disable watchdog.
    api_instance.pet_wdt_post(body)
except ApiException as e:
    print("Exception when calling WatchdogApi->petWdtPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Watchdog settings updated successfully.

Status: 400 - Invalid request body format.

Status: 500 - An error occurred while config watchdog.