Arduino IoT Cloud API

DashboardsV2

dashboardsV2Clone

clone dashboards_v2

Clone an existing dashboard


/v2/dashboards/{id}/clone

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/vnd.arduino.dashboardv2+json,application/vnd.goa.error+json" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/clone" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Clone clone = ; // Clone | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Clone(id, clone, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Clone");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final Clone clone = new Clone(); // Clone | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Clone clone = ; // Clone | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Clone(id, clone, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Clone");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
Clone *clone = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// clone dashboards_v2
[apiInstance dashboardsV2CloneWith:id
    clone:clone
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDashboardv2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var clone = ; // {Clone} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Clone(id, clone, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2CloneExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var clone = new Clone(); // Clone | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // clone dashboards_v2
                ArduinoDashboardv2 result = apiInstance.dashboardsV2Clone(id, clone, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Clone: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$clone = ; // Clone | 
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2Clone($id, $clone, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Clone: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $clone = WWW::OPenAPIClient::Object::Clone->new(); # Clone | 
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2Clone(id => $id, clone => $clone, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Clone: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
clone =  # Clone | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # clone dashboards_v2
    api_response = api_instance.dashboards_v2_clone(id, clone, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Clone: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let clone = ; // Clone
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Clone(id, clone, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
clone *

Responses


dashboardsV2Create

create dashboards_v2

Create a new dashboard


/v2/dashboards

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/vnd.arduino.dashboardv2+json,application/vnd.goa.error+json" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/dashboards" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        Dashboardv2 dashboardv2 = ; // Dashboardv2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Create(dashboardv2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Create");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Dashboardv2 dashboardv2 = new Dashboardv2(); // Dashboardv2 | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        Dashboardv2 dashboardv2 = ; // Dashboardv2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Create(dashboardv2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Create");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
Dashboardv2 *dashboardv2 = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// create dashboards_v2
[apiInstance dashboardsV2CreateWith:dashboardv2
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDashboardv2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var dashboardv2 = ; // {Dashboardv2} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Create(dashboardv2, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2CreateExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var dashboardv2 = new Dashboardv2(); // Dashboardv2 | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // create dashboards_v2
                ArduinoDashboardv2 result = apiInstance.dashboardsV2Create(dashboardv2, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Create: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$dashboardv2 = ; // Dashboardv2 | 
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2Create($dashboardv2, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Create: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $dashboardv2 = WWW::OPenAPIClient::Object::Dashboardv2->new(); # Dashboardv2 | 
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2Create(dashboardv2 => $dashboardv2, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Create: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
dashboardv2 =  # Dashboardv2 | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # create dashboards_v2
    api_response = api_instance.dashboards_v2_create(dashboardv2, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Create: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let dashboardv2 = ; // Dashboardv2
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Create(dashboardv2, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
dashboardv2 *

DashboardV2Payload describes a dashboard

Responses


dashboardsV2Delete

delete dashboards_v2

Delete a dashboard


/v2/dashboards/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/vnd.goa.error+json,text/plain" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2Delete(id, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Delete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2Delete(id, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Delete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// delete dashboards_v2
[apiInstance dashboardsV2DeleteWith:id
    xOrganization:xOrganization
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Delete(id, opts).then(function() {
  console.log('API called successfully.');
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2DeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // delete dashboards_v2
                apiInstance.dashboardsV2Delete(id, xOrganization);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Delete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$xOrganization = xOrganization_example; // String | 

try {
    $api_instance->dashboardsV2Delete($id, $xOrganization);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Delete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $xOrganization = xOrganization_example; # String | 

eval {
    $api_instance->dashboardsV2Delete(id => $id, xOrganization => $xOrganization);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Delete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # delete dashboards_v2
    api_instance.dashboards_v2_delete(id, xOrganization=xOrganization)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Delete: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Delete(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String

Responses


dashboardsV2DeleteShare

deleteShare dashboards_v2

Delete a user the dashboard has been shared with


/v2/dashboards/{id}/shares/{user_id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/vnd.goa.error+json,text/plain" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/shares/{user_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String userId = userId_example; // String | The id of the user
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2DeleteShare(id, userId, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2DeleteShare");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final String userId = new String(); // String | The id of the user
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String userId = userId_example; // String | The id of the user
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2DeleteShare(id, userId, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2DeleteShare");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
String *userId = userId_example; // The id of the user (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// deleteShare dashboards_v2
[apiInstance dashboardsV2DeleteShareWith:id
    userId:userId
    xOrganization:xOrganization
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var userId = userId_example; // {String} The id of the user
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2DeleteShare(id, userId, opts).then(function() {
  console.log('API called successfully.');
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2DeleteShareExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var userId = userId_example;  // String | The id of the user (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // deleteShare dashboards_v2
                apiInstance.dashboardsV2DeleteShare(id, userId, xOrganization);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2DeleteShare: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$userId = userId_example; // String | The id of the user
$xOrganization = xOrganization_example; // String | 

try {
    $api_instance->dashboardsV2DeleteShare($id, $userId, $xOrganization);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2DeleteShare: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $userId = userId_example; # String | The id of the user
my $xOrganization = xOrganization_example; # String | 

eval {
    $api_instance->dashboardsV2DeleteShare(id => $id, userId => $userId, xOrganization => $xOrganization);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2DeleteShare: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
userId = userId_example # String | The id of the user (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # deleteShare dashboards_v2
    api_instance.dashboards_v2_delete_share(id, userId, xOrganization=xOrganization)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2DeleteShare: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let userId = userId_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2DeleteShare(id, userId, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
user_id*
String
The id of the user
Required
Header parameters
Name Description
X-Organization
String

Responses



dashboardsV2List

list dashboards_v2

Returns the list of dashboards


/v2/dashboards

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.dashboardv2+json; type=collection,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/dashboards?name=name_example&user_id=userId_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String name = name_example; // String | The name of the dashboard
        String userId = userId_example; // String | The user_id of the dashboard's owner
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDashboardv2] result = apiInstance.dashboardsV2List(name, userId, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2List");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | The name of the dashboard
final String userId = new String(); // String | The user_id of the dashboard's owner
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String name = name_example; // String | The name of the dashboard
        String userId = userId_example; // String | The user_id of the dashboard's owner
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDashboardv2] result = apiInstance.dashboardsV2List(name, userId, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2List");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *name = name_example; // The name of the dashboard (optional) (default to null)
String *userId = userId_example; // The user_id of the dashboard's owner (optional) (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// list dashboards_v2
[apiInstance dashboardsV2ListWith:name
    userId:userId
    xOrganization:xOrganization
              completionHandler: ^(array[ArduinoDashboardv2] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var opts = {
  'name': name_example, // {String} The name of the dashboard
  'userId': userId_example, // {String} The user_id of the dashboard's owner
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2List(opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2ListExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var name = name_example;  // String | The name of the dashboard (optional)  (default to null)
            var userId = userId_example;  // String | The user_id of the dashboard's owner (optional)  (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // list dashboards_v2
                array[ArduinoDashboardv2] result = apiInstance.dashboardsV2List(name, userId, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2List: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$name = name_example; // String | The name of the dashboard
$userId = userId_example; // String | The user_id of the dashboard's owner
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2List($name, $userId, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2List: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $name = name_example; # String | The name of the dashboard
my $userId = userId_example; # String | The user_id of the dashboard's owner
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2List(name => $name, userId => $userId, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2List: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
name = name_example # String | The name of the dashboard (optional) (default to null)
userId = userId_example # String | The user_id of the dashboard's owner (optional) (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # list dashboards_v2
    api_response = api_instance.dashboards_v2_list(name=name, userId=userId, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2List: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let name = name_example; // String
    let userId = userId_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2List(name, userId, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
name
String
The name of the dashboard
user_id
String
The user_id of the dashboard's owner

Responses


dashboardsV2ListShares

listShares dashboards_v2

List of users the dashboard has been shared with


/v2/dashboards/{id}/shares

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.dashboardshare+json; type=collection,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/shares"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDashboardshare] result = apiInstance.dashboardsV2ListShares(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2ListShares");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDashboardshare] result = apiInstance.dashboardsV2ListShares(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2ListShares");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// listShares dashboards_v2
[apiInstance dashboardsV2ListSharesWith:id
    xOrganization:xOrganization
              completionHandler: ^(array[ArduinoDashboardshare] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2ListShares(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2ListSharesExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // listShares dashboards_v2
                array[ArduinoDashboardshare] result = apiInstance.dashboardsV2ListShares(id, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2ListShares: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2ListShares($id, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2ListShares: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2ListShares(id => $id, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2ListShares: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # listShares dashboards_v2
    api_response = api_instance.dashboards_v2_list_shares(id, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2ListShares: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2ListShares(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String

Responses


dashboardsV2RequestAccess

requestAccess dashboards_v2

Request access to a dashboard


/v2/dashboards/{id}/share_request

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/vnd.goa.error+json,text/plain" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/share_request" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Sharerequest sharerequest = ; // Sharerequest | 
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2RequestAccess(id, sharerequest, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2RequestAccess");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final Sharerequest sharerequest = new Sharerequest(); // Sharerequest | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Sharerequest sharerequest = ; // Sharerequest | 
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2RequestAccess(id, sharerequest, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2RequestAccess");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
Sharerequest *sharerequest = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// requestAccess dashboards_v2
[apiInstance dashboardsV2RequestAccessWith:id
    sharerequest:sharerequest
    xOrganization:xOrganization
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var sharerequest = ; // {Sharerequest} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2RequestAccess(id, sharerequest, opts).then(function() {
  console.log('API called successfully.');
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2RequestAccessExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var sharerequest = new Sharerequest(); // Sharerequest | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // requestAccess dashboards_v2
                apiInstance.dashboardsV2RequestAccess(id, sharerequest, xOrganization);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2RequestAccess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$sharerequest = ; // Sharerequest | 
$xOrganization = xOrganization_example; // String | 

try {
    $api_instance->dashboardsV2RequestAccess($id, $sharerequest, $xOrganization);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2RequestAccess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $sharerequest = WWW::OPenAPIClient::Object::Sharerequest->new(); # Sharerequest | 
my $xOrganization = xOrganization_example; # String | 

eval {
    $api_instance->dashboardsV2RequestAccess(id => $id, sharerequest => $sharerequest, xOrganization => $xOrganization);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2RequestAccess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
sharerequest =  # Sharerequest | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # requestAccess dashboards_v2
    api_instance.dashboards_v2_request_access(id, sharerequest, xOrganization=xOrganization)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2RequestAccess: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let sharerequest = ; // Sharerequest
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2RequestAccess(id, sharerequest, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
sharerequest *

Responses


dashboardsV2Share

share dashboards_v2

Share a dashboard


/v2/dashboards/{id}/shares

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/vnd.goa.error+json,text/plain" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/shares" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Dashboardshare dashboardshare = ; // Dashboardshare | 
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2Share(id, dashboardshare, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Share");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final Dashboardshare dashboardshare = new Dashboardshare(); // Dashboardshare | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Dashboardshare dashboardshare = ; // Dashboardshare | 
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.dashboardsV2Share(id, dashboardshare, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Share");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
Dashboardshare *dashboardshare = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// share dashboards_v2
[apiInstance dashboardsV2ShareWith:id
    dashboardshare:dashboardshare
    xOrganization:xOrganization
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var dashboardshare = ; // {Dashboardshare} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Share(id, dashboardshare, opts).then(function() {
  console.log('API called successfully.');
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2ShareExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var dashboardshare = new Dashboardshare(); // Dashboardshare | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // share dashboards_v2
                apiInstance.dashboardsV2Share(id, dashboardshare, xOrganization);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Share: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$dashboardshare = ; // Dashboardshare | 
$xOrganization = xOrganization_example; // String | 

try {
    $api_instance->dashboardsV2Share($id, $dashboardshare, $xOrganization);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Share: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $dashboardshare = WWW::OPenAPIClient::Object::Dashboardshare->new(); # Dashboardshare | 
my $xOrganization = xOrganization_example; # String | 

eval {
    $api_instance->dashboardsV2Share(id => $id, dashboardshare => $dashboardshare, xOrganization => $xOrganization);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Share: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
dashboardshare =  # Dashboardshare | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # share dashboards_v2
    api_instance.dashboards_v2_share(id, dashboardshare, xOrganization=xOrganization)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Share: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let dashboardshare = ; // Dashboardshare
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Share(id, dashboardshare, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
dashboardshare *

Responses


dashboardsV2Show

show dashboards_v2

Show a dashboard


/v2/dashboards/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.dashboardv2+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Show(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Show");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Show(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Show");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// show dashboards_v2
[apiInstance dashboardsV2ShowWith:id
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDashboardv2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Show(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2ShowExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // show dashboards_v2
                ArduinoDashboardv2 result = apiInstance.dashboardsV2Show(id, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Show: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2Show($id, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Show: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2Show(id => $id, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Show: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # show dashboards_v2
    api_response = api_instance.dashboards_v2_show(id, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Show: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Show(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String

Responses


dashboardsV2Template

template dashboards_v2

Get a template of the dashboard


/v2/dashboards/{id}/template

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.dashboardv2template+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}/template"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2template result = apiInstance.dashboardsV2Template(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Template");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2template result = apiInstance.dashboardsV2Template(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Template");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// template dashboards_v2
[apiInstance dashboardsV2TemplateWith:id
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDashboardv2template output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Template(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2TemplateExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // template dashboards_v2
                ArduinoDashboardv2template result = apiInstance.dashboardsV2Template(id, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Template: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2Template($id, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Template: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2Template(id => $id, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Template: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # template dashboards_v2
    api_response = api_instance.dashboards_v2_template(id, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Template: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Template(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String

Responses


dashboardsV2Update

update dashboards_v2

Updates an existing dashboard


/v2/dashboards/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/vnd.arduino.dashboardv2+json,application/vnd.goa.error+json" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/dashboards/{id}" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DashboardsV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Dashboardv2 dashboardv2 = ; // Dashboardv2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Update(id, dashboardv2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Update");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the dashboard
final Dashboardv2 dashboardv2 = new Dashboardv2(); // Dashboardv2 | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DashboardsV2Api;

public class DashboardsV2ApiExample {
    public static void main(String[] args) {
        DashboardsV2Api apiInstance = new DashboardsV2Api();
        String id = id_example; // String | The id of the dashboard
        Dashboardv2 dashboardv2 = ; // Dashboardv2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDashboardv2 result = apiInstance.dashboardsV2Update(id, dashboardv2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DashboardsV2Api#dashboardsV2Update");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DashboardsV2Api *apiInstance = [[DashboardsV2Api alloc] init];
String *id = id_example; // The id of the dashboard (default to null)
Dashboardv2 *dashboardv2 = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// update dashboards_v2
[apiInstance dashboardsV2UpdateWith:id
    dashboardv2:dashboardv2
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDashboardv2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DashboardsV2Api()
var id = id_example; // {String} The id of the dashboard
var dashboardv2 = ; // {Dashboardv2} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.dashboardsV2Update(id, dashboardv2, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class dashboardsV2UpdateExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DashboardsV2Api();
            var id = id_example;  // String | The id of the dashboard (default to null)
            var dashboardv2 = new Dashboardv2(); // Dashboardv2 | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // update dashboards_v2
                ArduinoDashboardv2 result = apiInstance.dashboardsV2Update(id, dashboardv2, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DashboardsV2Api.dashboardsV2Update: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DashboardsV2Api();
$id = id_example; // String | The id of the dashboard
$dashboardv2 = ; // Dashboardv2 | 
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->dashboardsV2Update($id, $dashboardv2, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DashboardsV2Api->dashboardsV2Update: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DashboardsV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DashboardsV2Api->new();
my $id = id_example; # String | The id of the dashboard
my $dashboardv2 = WWW::OPenAPIClient::Object::Dashboardv2->new(); # Dashboardv2 | 
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->dashboardsV2Update(id => $id, dashboardv2 => $dashboardv2, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DashboardsV2Api->dashboardsV2Update: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DashboardsV2Api()
id = id_example # String | The id of the dashboard (default to null)
dashboardv2 =  # Dashboardv2 | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # update dashboards_v2
    api_response = api_instance.dashboards_v2_update(id, dashboardv2, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DashboardsV2Api->dashboardsV2Update: %s\n" % e)
extern crate DashboardsV2Api;

pub fn main() {
    let id = id_example; // String
    let dashboardv2 = ; // Dashboardv2
    let xOrganization = xOrganization_example; // String

    let mut context = DashboardsV2Api::Context::default();
    let result = client.dashboardsV2Update(id, dashboardv2, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the dashboard
Required
Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
dashboardv2 *

DashboardV2Payload describes a dashboard

Responses


DevicesV2

devicesV2Create

create devices_v2

Creates a new device associated to the user.


/v2/devices

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/vnd.arduino.devicev2+json,application/vnd.goa.error+json" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/devices" \
 -d '{
  "connection_type" : "wifi",
  "serial" : "serial",
  "user_id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "fqbn" : "fqbn",
  "name" : "name",
  "wifi_fw_version" : "wifi_fw_version",
  "type" : "mkrwifi1010"
}' \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        CreateDevicesV2Payload createDevicesV2Payload = ; // CreateDevicesV2Payload | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Create(createDevicesV2Payload, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Create");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateDevicesV2Payload createDevicesV2Payload = new CreateDevicesV2Payload(); // CreateDevicesV2Payload | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        CreateDevicesV2Payload createDevicesV2Payload = ; // CreateDevicesV2Payload | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Create(createDevicesV2Payload, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Create");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
CreateDevicesV2Payload *createDevicesV2Payload = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// create devices_v2
[apiInstance devicesV2CreateWith:createDevicesV2Payload
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var createDevicesV2Payload = ; // {CreateDevicesV2Payload} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2Create(createDevicesV2Payload, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2CreateExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var createDevicesV2Payload = new CreateDevicesV2Payload(); // CreateDevicesV2Payload | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // create devices_v2
                ArduinoDevicev2 result = apiInstance.devicesV2Create(createDevicesV2Payload, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2Create: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$createDevicesV2Payload = ; // CreateDevicesV2Payload | 
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2Create($createDevicesV2Payload, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2Create: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $createDevicesV2Payload = WWW::OPenAPIClient::Object::CreateDevicesV2Payload->new(); # CreateDevicesV2Payload | 
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2Create(createDevicesV2Payload => $createDevicesV2Payload, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2Create: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
createDevicesV2Payload =  # CreateDevicesV2Payload | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # create devices_v2
    api_response = api_instance.devices_v2_create(createDevicesV2Payload, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2Create: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let createDevicesV2Payload = ; // CreateDevicesV2Payload
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2Create(createDevicesV2Payload, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
createDevicesV2Payload *

DeviceV2 describes a device.

Responses


devicesV2Delete

delete devices_v2

Removes a device associated to the user


/v2/devices/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/vnd.goa.error+json,text/plain" \
 "https://api2.arduino.cc/iot/v2/devices/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.devicesV2Delete(id, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Delete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String xOrganization = xOrganization_example; // String | 

        try {
            apiInstance.devicesV2Delete(id, xOrganization);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Delete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// delete devices_v2
[apiInstance devicesV2DeleteWith:id
    xOrganization:xOrganization
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2Delete(id, opts).then(function() {
  console.log('API called successfully.');
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2DeleteExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // delete devices_v2
                apiInstance.devicesV2Delete(id, xOrganization);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2Delete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$xOrganization = xOrganization_example; // String | 

try {
    $api_instance->devicesV2Delete($id, $xOrganization);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2Delete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $xOrganization = xOrganization_example; # String | 

eval {
    $api_instance->devicesV2Delete(id => $id, xOrganization => $xOrganization);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2Delete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # delete devices_v2
    api_instance.devices_v2_delete(id, xOrganization=xOrganization)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2Delete: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2Delete(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String

Responses


devicesV2GetEvents

getEvents devices_v2

GET device events


/v2/devices/{id}/events

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2.event.properties+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices/{id}/events?limit=56&start=start_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Integer limit = 56; // Integer | The number of events to select
        String start = start_example; // String | The time at which to start selecting events
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2EventProperties result = apiInstance.devicesV2GetEvents(id, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetEvents");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final Integer limit = new Integer(); // Integer | The number of events to select
final String start = new String(); // String | The time at which to start selecting events
final String xOrganization = new String(); // String | 

try {
    final result = await api_instance.devicesV2GetEvents(id, limit, start, xOrganization);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->devicesV2GetEvents: $e\n');
}

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Integer limit = 56; // Integer | The number of events to select
        String start = start_example; // String | The time at which to start selecting events
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2EventProperties result = apiInstance.devicesV2GetEvents(id, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetEvents");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
Integer *limit = 56; // The number of events to select (optional) (default to null)
String *start = start_example; // The time at which to start selecting events (optional) (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// getEvents devices_v2
[apiInstance devicesV2GetEventsWith:id
    limit:limit
    start:start
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2EventProperties output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var opts = {
  'limit': 56, // {Integer} The number of events to select
  'start': start_example, // {String} The time at which to start selecting events
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2GetEvents(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2GetEventsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var limit = 56;  // Integer | The number of events to select (optional)  (default to null)
            var start = start_example;  // String | The time at which to start selecting events (optional)  (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // getEvents devices_v2
                ArduinoDevicev2EventProperties result = apiInstance.devicesV2GetEvents(id, limit, start, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2GetEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$limit = 56; // Integer | The number of events to select
$start = start_example; // String | The time at which to start selecting events
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2GetEvents($id, $limit, $start, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2GetEvents: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $limit = 56; # Integer | The number of events to select
my $start = start_example; # String | The time at which to start selecting events
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2GetEvents(id => $id, limit => $limit, start => $start, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2GetEvents: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
limit = 56 # Integer | The number of events to select (optional) (default to null)
start = start_example # String | The time at which to start selecting events (optional) (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # getEvents devices_v2
    api_response = api_instance.devices_v2_get_events(id, limit=limit, start=start, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2GetEvents: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let limit = 56; // Integer
    let start = start_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2GetEvents(id, limit, start, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
limit
Integer
The number of events to select
start
String
The time at which to start selecting events

Responses


devicesV2GetProperties

getProperties devices_v2

GET device properties


/v2/devices/{id}/properties

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2properties+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices/{id}/properties?show_deleted=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Boolean showDeleted = true; // Boolean | If true, shows the soft deleted properties
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2properties result = apiInstance.devicesV2GetProperties(id, showDeleted, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetProperties");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final Boolean showDeleted = new Boolean(); // Boolean | If true, shows the soft deleted properties
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Boolean showDeleted = true; // Boolean | If true, shows the soft deleted properties
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2properties result = apiInstance.devicesV2GetProperties(id, showDeleted, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetProperties");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
Boolean *showDeleted = true; // If true, shows the soft deleted properties (optional) (default to false)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// getProperties devices_v2
[apiInstance devicesV2GetPropertiesWith:id
    showDeleted:showDeleted
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2properties output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var opts = {
  'showDeleted': true, // {Boolean} If true, shows the soft deleted properties
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2GetProperties(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2GetPropertiesExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var showDeleted = true;  // Boolean | If true, shows the soft deleted properties (optional)  (default to false)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // getProperties devices_v2
                ArduinoDevicev2properties result = apiInstance.devicesV2GetProperties(id, showDeleted, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2GetProperties: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$showDeleted = true; // Boolean | If true, shows the soft deleted properties
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2GetProperties($id, $showDeleted, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2GetProperties: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $showDeleted = true; # Boolean | If true, shows the soft deleted properties
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2GetProperties(id => $id, showDeleted => $showDeleted, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2GetProperties: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
showDeleted = true # Boolean | If true, shows the soft deleted properties (optional) (default to false)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # getProperties devices_v2
    api_response = api_instance.devices_v2_get_properties(id, showDeleted=showDeleted, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2GetProperties: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let showDeleted = true; // Boolean
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2GetProperties(id, showDeleted, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
show_deleted
Boolean
If true, shows the soft deleted properties

Responses


devicesV2GetStatusEvents

GetStatusEvents devices_v2

GET connection status events


/v2/devices/{id}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2.status.events+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices/{id}/status?limit=56&start=start_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Integer limit = 56; // Integer | The number of events to select
        String start = start_example; // String | The time at which to start selecting events
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2StatusEvents result = apiInstance.devicesV2GetStatusEvents(id, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetStatusEvents");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final Integer limit = new Integer(); // Integer | The number of events to select
final String start = new String(); // String | The time at which to start selecting events
final String xOrganization = new String(); // String | 

try {
    final result = await api_instance.devicesV2GetStatusEvents(id, limit, start, xOrganization);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->devicesV2GetStatusEvents: $e\n');
}

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Integer limit = 56; // Integer | The number of events to select
        String start = start_example; // String | The time at which to start selecting events
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2StatusEvents result = apiInstance.devicesV2GetStatusEvents(id, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2GetStatusEvents");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
Integer *limit = 56; // The number of events to select (optional) (default to 30)
String *start = start_example; // The time at which to start selecting events (optional) (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// GetStatusEvents devices_v2
[apiInstance devicesV2GetStatusEventsWith:id
    limit:limit
    start:start
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2StatusEvents output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var opts = {
  'limit': 56, // {Integer} The number of events to select
  'start': start_example, // {String} The time at which to start selecting events
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2GetStatusEvents(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2GetStatusEventsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var limit = 56;  // Integer | The number of events to select (optional)  (default to 30)
            var start = start_example;  // String | The time at which to start selecting events (optional)  (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // GetStatusEvents devices_v2
                ArduinoDevicev2StatusEvents result = apiInstance.devicesV2GetStatusEvents(id, limit, start, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2GetStatusEvents: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$limit = 56; // Integer | The number of events to select
$start = start_example; // String | The time at which to start selecting events
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2GetStatusEvents($id, $limit, $start, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2GetStatusEvents: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $limit = 56; # Integer | The number of events to select
my $start = start_example; # String | The time at which to start selecting events
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2GetStatusEvents(id => $id, limit => $limit, start => $start, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2GetStatusEvents: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
limit = 56 # Integer | The number of events to select (optional) (default to 30)
start = start_example # String | The time at which to start selecting events (optional) (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # GetStatusEvents devices_v2
    api_response = api_instance.devices_v2_get_status_events(id, limit=limit, start=start, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2GetStatusEvents: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let limit = 56; // Integer
    let start = start_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2GetStatusEvents(id, limit, start, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
limit
Integer
The number of events to select
start
String
The time at which to start selecting events

Responses


devicesV2List

list devices_v2

Returns the list of devices associated to the user


/v2/devices

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2+json; type=collection,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices?across_user_ids=true&serial=serial_example&tags="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        Boolean acrossUserIds = true; // Boolean | If true, returns all the devices
        String serial = serial_example; // String | Filter by device serial number
        array[String] tags = ; // array[String] | Filter by tags
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDevicev2] result = apiInstance.devicesV2List(acrossUserIds, serial, tags, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2List");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean acrossUserIds = new Boolean(); // Boolean | If true, returns all the devices
final String serial = new String(); // String | Filter by device serial number
final array[String] tags = new array[String](); // array[String] | Filter by tags
final String xOrganization = new String(); // String | 

try {
    final result = await api_instance.devicesV2List(acrossUserIds, serial, tags, xOrganization);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->devicesV2List: $e\n');
}

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        Boolean acrossUserIds = true; // Boolean | If true, returns all the devices
        String serial = serial_example; // String | Filter by device serial number
        array[String] tags = ; // array[String] | Filter by tags
        String xOrganization = xOrganization_example; // String | 

        try {
            array[ArduinoDevicev2] result = apiInstance.devicesV2List(acrossUserIds, serial, tags, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2List");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
Boolean *acrossUserIds = true; // If true, returns all the devices (optional) (default to false)
String *serial = serial_example; // Filter by device serial number (optional) (default to null)
array[String] *tags = ; // Filter by tags (optional) (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// list devices_v2
[apiInstance devicesV2ListWith:acrossUserIds
    serial:serial
    tags:tags
    xOrganization:xOrganization
              completionHandler: ^(array[ArduinoDevicev2] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var opts = {
  'acrossUserIds': true, // {Boolean} If true, returns all the devices
  'serial': serial_example, // {String} Filter by device serial number
  'tags': , // {array[String]} Filter by tags
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2List(opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2ListExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var acrossUserIds = true;  // Boolean | If true, returns all the devices (optional)  (default to false)
            var serial = serial_example;  // String | Filter by device serial number (optional)  (default to null)
            var tags = new array[String](); // array[String] | Filter by tags (optional)  (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // list devices_v2
                array[ArduinoDevicev2] result = apiInstance.devicesV2List(acrossUserIds, serial, tags, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2List: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$acrossUserIds = true; // Boolean | If true, returns all the devices
$serial = serial_example; // String | Filter by device serial number
$tags = ; // array[String] | Filter by tags
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2List($acrossUserIds, $serial, $tags, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2List: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $acrossUserIds = true; # Boolean | If true, returns all the devices
my $serial = serial_example; # String | Filter by device serial number
my $tags = []; # array[String] | Filter by tags
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2List(acrossUserIds => $acrossUserIds, serial => $serial, tags => $tags, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2List: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
acrossUserIds = true # Boolean | If true, returns all the devices (optional) (default to false)
serial = serial_example # String | Filter by device serial number (optional) (default to null)
tags =  # array[String] | Filter by tags (optional) (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # list devices_v2
    api_response = api_instance.devices_v2_list(acrossUserIds=acrossUserIds, serial=serial, tags=tags, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2List: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let acrossUserIds = true; // Boolean
    let serial = serial_example; // String
    let tags = ; // array[String]
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2List(acrossUserIds, serial, tags, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
across_user_ids
Boolean
If true, returns all the devices
serial
String
Filter by device serial number
tags
array[String]
Filter by tags

Responses


devicesV2Show

show devices_v2

Returns the device requested by the user


/v2/devices/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Show(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Show");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Show(id, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Show");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// show devices_v2
[apiInstance devicesV2ShowWith:id
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2Show(id, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2ShowExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // show devices_v2
                ArduinoDevicev2 result = apiInstance.devicesV2Show(id, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2Show: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2Show($id, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2Show: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2Show(id => $id, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2Show: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # show devices_v2
    api_response = api_instance.devices_v2_show(id, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2Show: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2Show(id, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String

Responses


devicesV2Timeseries

timeseries devices_v2

GET device properties values in a range of time


/v2/devices/{id}/properties/{pid}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/vnd.arduino.devicev2propertyvalues+json,application/vnd.goa.error+json" \
 "https://api2.arduino.cc/iot/v2/devices/{id}/properties/{pid}?limit=56&start=start_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String pid = pid_example; // String | The id of the property
        Integer limit = 56; // Integer | The number of properties to select
        String start = start_example; // String | The time at which to start selecting properties
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2propertyvalues result = apiInstance.devicesV2Timeseries(id, pid, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Timeseries");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final String pid = new String(); // String | The id of the property
final Integer limit = new Integer(); // Integer | The number of properties to select
final String start = new String(); // String | The time at which to start selecting properties
final String xOrganization = new String(); // String | 

try {
    final result = await api_instance.devicesV2Timeseries(id, pid, limit, start, xOrganization);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->devicesV2Timeseries: $e\n');
}

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        String pid = pid_example; // String | The id of the property
        Integer limit = 56; // Integer | The number of properties to select
        String start = start_example; // String | The time at which to start selecting properties
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2propertyvalues result = apiInstance.devicesV2Timeseries(id, pid, limit, start, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Timeseries");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
String *pid = pid_example; // The id of the property (default to null)
Integer *limit = 56; // The number of properties to select (optional) (default to null)
String *start = start_example; // The time at which to start selecting properties (optional) (default to null)
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// timeseries devices_v2
[apiInstance devicesV2TimeseriesWith:id
    pid:pid
    limit:limit
    start:start
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2propertyvalues output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var pid = pid_example; // {String} The id of the property
var opts = {
  'limit': 56, // {Integer} The number of properties to select
  'start': start_example, // {String} The time at which to start selecting properties
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2Timeseries(id, pid, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2TimeseriesExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var pid = pid_example;  // String | The id of the property (default to null)
            var limit = 56;  // Integer | The number of properties to select (optional)  (default to null)
            var start = start_example;  // String | The time at which to start selecting properties (optional)  (default to null)
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // timeseries devices_v2
                ArduinoDevicev2propertyvalues result = apiInstance.devicesV2Timeseries(id, pid, limit, start, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2Timeseries: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$pid = pid_example; // String | The id of the property
$limit = 56; // Integer | The number of properties to select
$start = start_example; // String | The time at which to start selecting properties
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2Timeseries($id, $pid, $limit, $start, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2Timeseries: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $pid = pid_example; # String | The id of the property
my $limit = 56; # Integer | The number of properties to select
my $start = start_example; # String | The time at which to start selecting properties
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2Timeseries(id => $id, pid => $pid, limit => $limit, start => $start, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2Timeseries: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
pid = pid_example # String | The id of the property (default to null)
limit = 56 # Integer | The number of properties to select (optional) (default to null)
start = start_example # String | The time at which to start selecting properties (optional) (default to null)
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # timeseries devices_v2
    api_response = api_instance.devices_v2_timeseries(id, pid, limit=limit, start=start, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2Timeseries: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let pid = pid_example; // String
    let limit = 56; // Integer
    let start = start_example; // String
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2Timeseries(id, pid, limit, start, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
pid*
String
The id of the property
Required
Header parameters
Name Description
X-Organization
String
Query parameters
Name Description
limit
Integer
The number of properties to select
start
String
The time at which to start selecting properties

Responses


devicesV2Update

update devices_v2

Updates a device associated to the user


/v2/devices/{id}

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/vnd.arduino.devicev2+json,application/vnd.goa.error+json" \
 -H "Content-Type: application/json,application/x-www-form-urlencoded" \
 "https://api2.arduino.cc/iot/v2/devices/{id}" \
 -d 'Custom MIME type example not yet supported: application/x-www-form-urlencoded'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DevicesV2Api;

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

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

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Devicev2 devicev2 = ; // Devicev2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Update(id, devicev2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Update");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The id of the device
final Devicev2 devicev2 = new Devicev2(); // Devicev2 | 
final String xOrganization = new String(); // String | 

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

import org.openapitools.client.api.DevicesV2Api;

public class DevicesV2ApiExample {
    public static void main(String[] args) {
        DevicesV2Api apiInstance = new DevicesV2Api();
        String id = id_example; // String | The id of the device
        Devicev2 devicev2 = ; // Devicev2 | 
        String xOrganization = xOrganization_example; // String | 

        try {
            ArduinoDevicev2 result = apiInstance.devicesV2Update(id, devicev2, xOrganization);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DevicesV2Api#devicesV2Update");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
DevicesV2Api *apiInstance = [[DevicesV2Api alloc] init];
String *id = id_example; // The id of the device (default to null)
Devicev2 *devicev2 = ; // 
String *xOrganization = xOrganization_example; //  (optional) (default to null)

// update devices_v2
[apiInstance devicesV2UpdateWith:id
    devicev2:devicev2
    xOrganization:xOrganization
              completionHandler: ^(ArduinoDevicev2 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ArduinoIotClient = require('@arduino/arduino-iot-client');
var defaultClient = ArduinoIotClient.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ArduinoIotClient.DevicesV2Api()
var id = id_example; // {String} The id of the device
var devicev2 = ; // {Devicev2} 
var opts = {
  'xOrganization': xOrganization_example // {String} 
};
api.devicesV2Update(id, devicev2, opts).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

using System;
using System.Diagnostics;
using iot.Api;
using iot.Client;
using iot.Model;

namespace Example
{
    public class devicesV2UpdateExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new DevicesV2Api();
            var id = id_example;  // String | The id of the device (default to null)
            var devicev2 = new Devicev2(); // Devicev2 | 
            var xOrganization = xOrganization_example;  // String |  (optional)  (default to null)

            try {
                // update devices_v2
                ArduinoDevicev2 result = apiInstance.devicesV2Update(id, devicev2, xOrganization);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DevicesV2Api.devicesV2Update: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DevicesV2Api();
$id = id_example; // String | The id of the device
$devicev2 = ; // Devicev2 | 
$xOrganization = xOrganization_example; // String | 

try {
    $result = $api_instance->devicesV2Update($id, $devicev2, $xOrganization);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DevicesV2Api->devicesV2Update: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DevicesV2Api;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DevicesV2Api->new();
my $id = id_example; # String | The id of the device
my $devicev2 = WWW::OPenAPIClient::Object::Devicev2->new(); # Devicev2 | 
my $xOrganization = xOrganization_example; # String | 

eval {
    my $result = $api_instance->devicesV2Update(id => $id, devicev2 => $devicev2, xOrganization => $xOrganization);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DevicesV2Api->devicesV2Update: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.DevicesV2Api()
id = id_example # String | The id of the device (default to null)
devicev2 =  # Devicev2 | 
xOrganization = xOrganization_example # String |  (optional) (default to null)

try:
    # update devices_v2
    api_response = api_instance.devices_v2_update(id, devicev2, xOrganization=xOrganization)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DevicesV2Api->devicesV2Update: %s\n" % e)
extern crate DevicesV2Api;

pub fn main() {
    let id = id_example; // String
    let devicev2 = ; // Devicev2
    let xOrganization = xOrganization_example; // String

    let mut context = DevicesV2Api::Context::default();
    let result = client.devicesV2Update(id, devicev2, xOrganization, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
String
The id of the device
Required
Header parameters
Name Description
X-Organization
String
Body parameters
Name Description
devicev2 *

DeviceV2 describes a device.

Responses