# Siemens Inventory REST API

## API and SDK Documentation

Version: 1.0.0

REST API for Inventory Service

# Device

# getDeviceTypesByName

Gets Device Types based on deviceTypeName

    /device-types/name/like/{deviceTypeName}

### Usage and SDK Samples

    curl -X GET "https://localhost/inventory-service/api/v1/device-types/name/like/{deviceTypeName}"

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

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

    public class DeviceApiExample {

        public static void main(String[] args) {

            DeviceApi apiInstance = new DeviceApi();
            String deviceTypeName = deviceTypeName_example; // String | Name of device type
            try {
                array[DeviceType] result = apiInstance.getDeviceTypesByName(deviceTypeName);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceApi#getDeviceTypesByName");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceApi;

    public class DeviceApiExample {

        public static void main(String[] args) {
            DeviceApi apiInstance = new DeviceApi();
            String deviceTypeName = deviceTypeName_example; // String | Name of device type
            try {
                array[DeviceType] result = apiInstance.getDeviceTypesByName(deviceTypeName);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceApi#getDeviceTypesByName");
                e.printStackTrace();
            }
        }
    }

    String *deviceTypeName = deviceTypeName_example; // Name of device type

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

    // Gets Device Types based on deviceTypeName
    [apiInstance getDeviceTypesByNameWith:deviceTypeName
                  completionHandler: ^(array[DeviceType] output, NSError* error) {
                                if (output) {
                                    NSLog(@"%@", output);
                                }
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceApi()

    var deviceTypeName = deviceTypeName_example; // {String} Name of device type

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

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

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

                var apiInstance = new DeviceApi();
                var deviceTypeName = deviceTypeName_example;  // String | Name of device type

                try
                {
                    // Gets Device Types based on deviceTypeName
                    array[DeviceType] result = apiInstance.getDeviceTypesByName(deviceTypeName);
                    Debug.WriteLine(result);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceApi.getDeviceTypesByName: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceApi();
    $deviceTypeName = deviceTypeName_example; // String | Name of device type

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

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

    my $api_instance = WWW::SwaggerClient::DeviceApi->new();
    my $deviceTypeName = deviceTypeName_example; # String | Name of device type

    eval {
        my $result = $api_instance->getDeviceTypesByName(deviceTypeName => $deviceTypeName);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DeviceApi->getDeviceTypesByName: $@\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.DeviceApi()
    deviceTypeName = deviceTypeName_example # String | Name of device type

    try:
        # Gets Device Types based on deviceTypeName
        api_response = api_instance.get_device_types_by_name(deviceTypeName)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DeviceApi->getDeviceTypesByName: %s\n" % e)

## Parameters

Path parameters

Name | Description
--- | ---
deviceTypeName* | String Name of device type Required

## Responses

### Status: 200 - All Device Types filtered out by

# DeviceType

# createDeviceType

Creates new Device Type

    /device-types

### Usage and SDK Samples

    curl -X POST "https://localhost/inventory-service/api/v1/device-types"

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

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

    public class DeviceTypeApiExample {

        public static void main(String[] args) {

            DeviceTypeApi apiInstance = new DeviceTypeApi();
            DeviceType body = ; // DeviceType | Device Type object that needs to be created
            try {
                DeviceType result = apiInstance.createDeviceType(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#createDeviceType");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceTypeApi;

    public class DeviceTypeApiExample {

        public static void main(String[] args) {
            DeviceTypeApi apiInstance = new DeviceTypeApi();
            DeviceType body = ; // DeviceType | Device Type object that needs to be created
            try {
                DeviceType result = apiInstance.createDeviceType(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#createDeviceType");
                e.printStackTrace();
            }
        }
    }

    DeviceType *body = ; // Device Type object that needs to be created

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

    // Creates new Device Type
    [apiInstance createDeviceTypeWith:body
                  completionHandler: ^(DeviceType output, NSError* error) {
                                if (output) {
                                    NSLog(@"%@", output);
                                }
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceTypeApi()

    var body = ; // {DeviceType} Device Type object that needs to be created

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

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

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

                var apiInstance = new DeviceTypeApi();
                var body = new DeviceType(); // DeviceType | Device Type object that needs to be created

                try
                {
                    // Creates new Device Type
                    DeviceType result = apiInstance.createDeviceType(body);
                    Debug.WriteLine(result);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceTypeApi.createDeviceType: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceTypeApi();
    $body = ; // DeviceType | Device Type object that needs to be created

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

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

    my $api_instance = WWW::SwaggerClient::DeviceTypeApi->new();
    my $body = WWW::SwaggerClient::Object::DeviceType->new(); # DeviceType | Device Type object that needs to be created

    eval {
        my $result = $api_instance->createDeviceType(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DeviceTypeApi->createDeviceType: $@\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.DeviceTypeApi()
    body =  # DeviceType | Device Type object that needs to be created

    try:
        # Creates new Device Type
        api_response = api_instance.create_device_type(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DeviceTypeApi->createDeviceType: %s\n" % e)

## Parameters

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - DeviceInternal Type created

### Status: 405 - Invalid input

# deleteDeviceType

Deletes an Device Type

    /device-types/{deviceTypeId}

### Usage and SDK Samples

    curl -X DELETE "https://localhost/inventory-service/api/v1/device-types/{deviceTypeId}"

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

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

    public class DeviceTypeApiExample {

        public static void main(String[] args) {

            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            try {
                apiInstance.deleteDeviceType(deviceTypeId);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#deleteDeviceType");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceTypeApi;

    public class DeviceTypeApiExample {

        public static void main(String[] args) {
            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            try {
                apiInstance.deleteDeviceType(deviceTypeId);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#deleteDeviceType");
                e.printStackTrace();
            }
        }
    }

    Long *deviceTypeId = 789; // Device Type's id

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

    // Deletes an Device Type
    [apiInstance deleteDeviceTypeWith:deviceTypeId
                  completionHandler: ^(NSError* error) {
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceTypeApi()

    var deviceTypeId = 789; // {Long} Device Type's id

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteDeviceType(deviceTypeId, callback);

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

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

                var apiInstance = new DeviceTypeApi();
                var deviceTypeId = 789;  // Long | Device Type's id

                try
                {
                    // Deletes an Device Type
                    apiInstance.deleteDeviceType(deviceTypeId);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceTypeApi.deleteDeviceType: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceTypeApi();
    $deviceTypeId = 789; // Long | Device Type's id

    try {
        $api_instance->deleteDeviceType($deviceTypeId);
    } catch (Exception $e) {
        echo 'Exception when calling DeviceTypeApi->deleteDeviceType: ', $e->getMessage(), PHP_EOL;
    }
    ?>

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

    my $api_instance = WWW::SwaggerClient::DeviceTypeApi->new();
    my $deviceTypeId = 789; # Long | Device Type's id

    eval {
        $api_instance->deleteDeviceType(deviceTypeId => $deviceTypeId);
    };
    if ($@) {
        warn "Exception when calling DeviceTypeApi->deleteDeviceType: $@\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.DeviceTypeApi()
    deviceTypeId = 789 # Long | Device Type's id

    try:
        # Deletes an Device Type
        api_instance.delete_device_type(deviceTypeId)
    except ApiException as e:
        print("Exception when calling DeviceTypeApi->deleteDeviceType: %s\n" % e)

## Parameters

Path parameters

Name | Description
--- | ---
deviceTypeId* | Long (int64) Device Type's id Required

## Responses

### Status: 200 - Device Type was deleted.

### Status: 404 - Specified Device Type does not exist.

# getDeviceType

Gets Device Type based on deviceTypeId

    /device-types/{deviceTypeId}

### Usage and SDK Samples

    curl -X GET "https://localhost/inventory-service/api/v1/device-types/{deviceTypeId}"

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

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

    public class DeviceTypeApiExample {

        public static void main(String[] args) {

            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            try {
                DeviceType result = apiInstance.getDeviceType(deviceTypeId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#getDeviceType");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceTypeApi;

    public class DeviceTypeApiExample {

        public static void main(String[] args) {
            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            try {
                DeviceType result = apiInstance.getDeviceType(deviceTypeId);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#getDeviceType");
                e.printStackTrace();
            }
        }
    }

    Long *deviceTypeId = 789; // Device Type's id

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

    // Gets Device Type based on deviceTypeId
    [apiInstance getDeviceTypeWith:deviceTypeId
                  completionHandler: ^(DeviceType output, NSError* error) {
                                if (output) {
                                    NSLog(@"%@", output);
                                }
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceTypeApi()

    var deviceTypeId = 789; // {Long} Device Type's id

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

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

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

                var apiInstance = new DeviceTypeApi();
                var deviceTypeId = 789;  // Long | Device Type's id

                try
                {
                    // Gets Device Type based on deviceTypeId
                    DeviceType result = apiInstance.getDeviceType(deviceTypeId);
                    Debug.WriteLine(result);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceTypeApi.getDeviceType: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceTypeApi();
    $deviceTypeId = 789; // Long | Device Type's id

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

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

    my $api_instance = WWW::SwaggerClient::DeviceTypeApi->new();
    my $deviceTypeId = 789; # Long | Device Type's id

    eval {
        my $result = $api_instance->getDeviceType(deviceTypeId => $deviceTypeId);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DeviceTypeApi->getDeviceType: $@\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.DeviceTypeApi()
    deviceTypeId = 789 # Long | Device Type's id

    try:
        # Gets Device Type based on deviceTypeId
        api_response = api_instance.get_device_type(deviceTypeId)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DeviceTypeApi->getDeviceType: %s\n" % e)

## Parameters

Path parameters

Name | Description
--- | ---
deviceTypeId* | Long (int64) Device Type's id Required

## Responses

### Status: 200 - The Device Type

### Status: 404 - Requested Device Type does not exist.

# getDeviceTypes

Gets all Device types

    /device-types

### Usage and SDK Samples

    curl -X GET "https://localhost/inventory-service/api/v1/device-types"

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

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

    public class DeviceTypeApiExample {

        public static void main(String[] args) {

            DeviceTypeApi apiInstance = new DeviceTypeApi();
            try {
                array[DeviceType] result = apiInstance.getDeviceTypes();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#getDeviceTypes");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceTypeApi;

    public class DeviceTypeApiExample {

        public static void main(String[] args) {
            DeviceTypeApi apiInstance = new DeviceTypeApi();
            try {
                array[DeviceType] result = apiInstance.getDeviceTypes();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#getDeviceTypes");
                e.printStackTrace();
            }
        }
    }

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

    // Gets all Device types
    [apiInstance getDeviceTypesWithCompletionHandler:
                  ^(array[DeviceType] output, NSError* error) {
                                if (output) {
                                    NSLog(@"%@", output);
                                }
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceTypeApi()

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

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

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

                var apiInstance = new DeviceTypeApi();

                try
                {
                    // Gets all Device types
                    array[DeviceType] result = apiInstance.getDeviceTypes();
                    Debug.WriteLine(result);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceTypeApi.getDeviceTypes: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceTypeApi();

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

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

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

    eval {
        my $result = $api_instance->getDeviceTypes();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DeviceTypeApi->getDeviceTypes: $@\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.DeviceTypeApi()

    try:
        # Gets all Device types
        api_response = api_instance.get_device_types()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DeviceTypeApi->getDeviceTypes: %s\n" % e)

## Parameters

## Responses

### Status: 200 - All Device Types

# updateDeviceType

Updates Device Type based on deviceTypeId

    /device-types/{deviceTypeId}

### Usage and SDK Samples

    curl -X PUT "https://localhost/inventory-service/api/v1/device-types/{deviceTypeId}"

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

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

    public class DeviceTypeApiExample {

        public static void main(String[] args) {

            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            DeviceType body = ; // DeviceType | Device Type object that needs to be updated
            try {
                DeviceType result = apiInstance.updateDeviceType(deviceTypeId, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#updateDeviceType");
                e.printStackTrace();
            }
        }
    }

    import io.swagger.client.api.DeviceTypeApi;

    public class DeviceTypeApiExample {

        public static void main(String[] args) {
            DeviceTypeApi apiInstance = new DeviceTypeApi();
            Long deviceTypeId = 789; // Long | Device Type's id
            DeviceType body = ; // DeviceType | Device Type object that needs to be updated
            try {
                DeviceType result = apiInstance.updateDeviceType(deviceTypeId, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DeviceTypeApi#updateDeviceType");
                e.printStackTrace();
            }
        }
    }

    Long *deviceTypeId = 789; // Device Type's id
    DeviceType *body = ; // Device Type object that needs to be updated

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

    // Updates Device Type based on deviceTypeId
    [apiInstance updateDeviceTypeWith:deviceTypeId
        body:body
                  completionHandler: ^(DeviceType output, NSError* error) {
                                if (output) {
                                    NSLog(@"%@", output);
                                }
                                if (error) {
                                    NSLog(@"Error: %@", error);
                                }
                            }];

    var SiemensInventoryRestApi = require('siemens_inventory_rest_api');

    var api = new SiemensInventoryRestApi.DeviceTypeApi()

    var deviceTypeId = 789; // {Long} Device Type's id

    var body = ; // {DeviceType} Device Type object that needs to be updated

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

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

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

                var apiInstance = new DeviceTypeApi();
                var deviceTypeId = 789;  // Long | Device Type's id
                var body = new DeviceType(); // DeviceType | Device Type object that needs to be updated

                try
                {
                    // Updates Device Type based on deviceTypeId
                    DeviceType result = apiInstance.updateDeviceType(deviceTypeId, body);
                    Debug.WriteLine(result);
                }
                catch (Exception e)
                {
                    Debug.Print("Exception when calling DeviceTypeApi.updateDeviceType: " + e.Message );
                }
            }
        }
    }

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

    $api_instance = new Swagger\Client\Api\DeviceTypeApi();
    $deviceTypeId = 789; // Long | Device Type's id
    $body = ; // DeviceType | Device Type object that needs to be updated

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

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

    my $api_instance = WWW::SwaggerClient::DeviceTypeApi->new();
    my $deviceTypeId = 789; # Long | Device Type's id
    my $body = WWW::SwaggerClient::Object::DeviceType->new(); # DeviceType | Device Type object that needs to be updated

    eval {
        my $result = $api_instance->updateDeviceType(deviceTypeId => $deviceTypeId, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DeviceTypeApi->updateDeviceType: $@\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.DeviceTypeApi()
    deviceTypeId = 789 # Long | Device Type's id
    body =  # DeviceType | Device Type object that needs to be updated

    try:
        # Updates Device Type based on deviceTypeId
        api_response = api_instance.update_device_type(deviceTypeId, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DeviceTypeApi->updateDeviceType: %s\n" % e)

## Parameters

Path parameters

Name | Description
--- | ---
deviceTypeId* | Long (int64) Device Type's id Required

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 200 - The Device Type

### Status: 404 - Requested DeviceInternal Type does not exist.

Generated 2018-12-11T17:23:58.201+01:00