DataBag

Account

addAccount

Add a new account. Basic auth will be used for the accounts username and password. Access granted to valid create account token.

/account/profile

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//account/profile"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicCredentials
        HttpBasicAuth basicCredentials = (HttpBasicAuth) defaultClient.getAuthentication("basicCredentials");
        basicCredentials.setUsername("YOUR USERNAME");
        basicCredentials.setPassword("YOUR PASSWORD");


        AccountApi apiInstance = new AccountApi();
        try {
            Profile result = apiInstance.addAccount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#addAccount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicCredentials)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance addAccountWithCompletionHandler: 
              ^(Profile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicCredentials
var basicCredentials = defaultClient.authentications['basicCredentials'];
basicCredentials.username = 'YOUR USERNAME'
basicCredentials.password = 'YOUR PASSWORD'


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

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

namespace Example
{
    public class addAccountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicCredentials
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                Profile result = apiInstance.addAccount();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.addAccount: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicCredentials
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicCredentials
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicCredentials
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.add_account()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->addAccount: %s\n" % e)

Parameters

Responses

Status: 201 - successful operation

Schema

Status: 400 - invalid handle or password

Status: 401 - permission denied

Status: 500 - internal server error

addAccountApp

Generate token to attach an app to the account. Access granted to account's username and password.

/account/apps

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//account/apps"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class addAccountAppExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                'String' result = apiInstance.addAccountApp();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.addAccountApp: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.add_account_app()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->addAccountApp: %s\n" % e)

Parameters

Responses

Status: 201 - generated

Schema

Status: 401 - invalid password

Status: 410 - account disabled

Status: 500 - internal server error

addAccountAuthentication

Generate token to reset authentication. Access granted to account's login and password.

/account/auth

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//account/auth"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class addAccountAuthenticationExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                'String' result = apiInstance.addAccountAuthentication();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.addAccountAuthentication: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.add_account_authentication()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->addAccountAuthentication: %s\n" % e)

Parameters

Responses

Status: 201 - generated

Schema

Status: 401 - invalid password

Status: 500 - internal server error

getAccountApps

Get list of attached apps to account. Access granted to account's username and password.

/account/apps

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//account/apps"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getAccountAppsWithCompletionHandler: 
              ^(array[App] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getAccountAppsExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                array[App] result = apiInstance.getAccountApps();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountApps: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_account_apps()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountApps: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 500 - internal server error

getAccountAsset

Get asset assigned to an account. The endpoint supports byte-range requests and responds with the content-type set appropriatly. Access granted to the app tokens of the account holder and in the case of non-original assets, the contact token for accounts with which the article is shared.

/account/assets/{assetId}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/octet-stream"\
"//account/assets/{assetId}"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        String assetId = assetId_example; // String | specified asset id
        try {
            byte[] result = apiInstance.getAccountAsset(assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String assetId = assetId_example; // String | specified asset id
        try {
            byte[] result = apiInstance.getAccountAsset(assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountAsset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *assetId = assetId_example; // specified asset id

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

[apiInstance getAccountAssetWith:assetId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var assetId = assetId_example; // {{String}} specified asset id

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

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

namespace Example
{
    public class getAccountAssetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();
            var assetId = assetId_example;  // String | specified asset id

            try
            {
                byte[] result = apiInstance.getAccountAsset(assetId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountAsset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAccountApi();
$assetId = assetId_example; // String | specified asset id

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $assetId = assetId_example; # String | specified asset id

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AccountApi()
assetId = assetId_example # String | specified asset id

try: 
    api_response = api_instance.get_account_asset(assetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountAsset: %s\n" % e)

Parameters

Path parameters

Name	Description
assetId*	String specified asset id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - asset or article not found

Status: 500 - internal server error

getAccountImage

Get profile image. Access granted to account's username and password

/account/profile/image

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/octet-stream"\
"//account/profile/image"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        try {
            byte[] result = apiInstance.getAccountImage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getAccountImageWithCompletionHandler: 
              ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getAccountImageExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                byte[] result = apiInstance.getAccountImage();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_account_image()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountImage: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 405 - invalid image

Status: 500 - internal server error

getAccountListing

Get profile of searchable accounts. Endpoint is publically accessible.

/account/listing

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//account/listing?guid="

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String guid = guid_example; // String | filter for specified guid
        try {
            array[Profile] result = apiInstance.getAccountListing(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountListing");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String guid = guid_example; // String | filter for specified guid
        try {
            array[Profile] result = apiInstance.getAccountListing(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountListing");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *guid = guid_example; // filter for specified guid (optional)

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

[apiInstance getAccountListingWith:guid
              completionHandler: ^(array[Profile] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AccountApi()
var opts = { 
  'guid': guid_example // {{String}} filter for specified guid
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAccountListing(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var guid = guid_example;  // String | filter for specified guid (optional) 

            try
            {
                array[Profile] result = apiInstance.getAccountListing(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountListing: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$guid = guid_example; // String | filter for specified guid

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $guid = guid_example; # String | filter for specified guid

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

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
guid = guid_example # String | filter for specified guid (optional)

try: 
    api_response = api_instance.get_account_listing(guid=guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountListing: %s\n" % e)

Parameters

Query parameters

Name	Description
guid	String filter for specified guid

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 500 - internal server error

getAccountProfile

Get account profile. Access granted to account's username and password.

/account/profile

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//account/profile"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        try {
            Profile result = apiInstance.getAccountProfile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getAccountProfileWithCompletionHandler: 
              ^(Profile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getAccountProfileExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                Profile result = apiInstance.getAccountProfile();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountProfile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_account_profile()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountProfile: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

Status: 401 - authentication error

Status: 500 - internal server error

getAccountStatus

Get disabled status of account. Authorized to account username and password.

/account/status

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//account/status"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        try {
            AccountStatus result = apiInstance.getAccountStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getAccountStatusWithCompletionHandler: 
              ^(AccountStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getAccountStatusExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                AccountStatus result = apiInstance.getAccountStatus();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_account_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountStatus: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

Status: 401 - authentication error

Status: 500 - internal server error

getAccountToken

Check if account reset token or account create token is valid. Access granted to valid create or reset token.

/account/token

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//account/token"

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

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

public class AccountApiExample {

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


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

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


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

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

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


            var apiInstance = new AccountApi();

            try
            {
                'String' result = apiInstance.getAccountToken();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountToken: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    api_response = api_instance.get_account_token()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountToken: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 500 - internal server error

getAccountUsername

Check if username is available. Access granted account reset token or account create token.

/account/available

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//account/available?username="

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | username to check
        try {
            'Boolean' result = apiInstance.getAccountUsername(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountUsername");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | username to check
        try {
            'Boolean' result = apiInstance.getAccountUsername(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#getAccountUsername");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *username = username_example; // username to check

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

[apiInstance getAccountUsernameWith:username
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AccountApi()
var username = username_example; // {{String}} username to check

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

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

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


            var apiInstance = new AccountApi();
            var username = username_example;  // String | username to check

            try
            {
                'Boolean' result = apiInstance.getAccountUsername(username);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.getAccountUsername: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$username = username_example; // String | username to check

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $username = username_example; # String | username to check

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

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
username = username_example # String | username to check

try: 
    api_response = api_instance.get_account_username(username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->getAccountUsername: %s\n" % e)

Parameters

Query parameters

Name	Description
username*	String username to check Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 500 - internal server error

removeAccount

Delete account. Access granted to valid create account token.

/account/profile

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Basic [[basicHash]]"\
"//account/profile"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.removeAccount();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#removeAccount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.removeAccount();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#removeAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance removeAccountWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeAccount(callback);

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

namespace Example
{
    public class removeAccountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                apiInstance.removeAccount();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.removeAccount: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->removeAccount();
};
if ($@) {
    warn "Exception when calling AccountApi->removeAccount: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.remove_account()
except ApiException as e:
    print("Exception when calling AccountApi->removeAccount: %s\n" % e)

Parameters

Responses

Status: 201 - successful operation

Status: 401 - permission denied

Status: 500 - internal server error

removeAccountApp

Get list of attached apps. Access granted to account's username and password.

/account/apps/{appId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Basic [[basicHash]]"\
"//account/apps/{appId}"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        String appId = appId_example; // String | specified app id
        try {
            apiInstance.removeAccountApp(appId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#removeAccountApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String appId = appId_example; // String | specified app id
        try {
            apiInstance.removeAccountApp(appId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#removeAccountApp");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *appId = appId_example; // specified app id

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

[apiInstance removeAccountAppWith:appId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var appId = appId_example; // {{String}} specified app id

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

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

namespace Example
{
    public class removeAccountAppExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();
            var appId = appId_example;  // String | specified app id

            try
            {
                apiInstance.removeAccountApp(appId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.removeAccountApp: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAccountApi();
$appId = appId_example; // String | specified app id

try {
    $api_instance->removeAccountApp($appId);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->removeAccountApp: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $appId = appId_example; # String | specified app id

eval { 
    $api_instance->removeAccountApp(appId => $appId);
};
if ($@) {
    warn "Exception when calling AccountApi->removeAccountApp: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AccountApi()
appId = appId_example # String | specified app id

try: 
    api_instance.remove_account_app(appId)
except ApiException as e:
    print("Exception when calling AccountApi->removeAccountApp: %s\n" % e)

Parameters

Path parameters

Name	Description
appId*	String specified app id Required

Responses

Status: 200 - successful operation

Status: 401 - invalid password

Status: 404 - app not found

Status: 410 - account disabled

Status: 500 - internal server error

setAccountApp

Apply the token to attach an app to the account. Access granted to valid attach token.

/account/apps

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//account/apps"

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        AppData body = ; // AppData | 
        try {
            'String' result = apiInstance.setAccountApp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
AppData *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AccountApi()
var opts = { 
  'body':  // {{AppData}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setAccountApp(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new AppData(); // AppData |  (optional) 

            try
            {
                'String' result = apiInstance.setAccountApp(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.setAccountApp: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // AppData | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # AppData |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - generated

Schema

Status: 401 - invalid token

Status: 406 - app limit reached

Status: 410 - account disabled

Status: 500 - internal server error

setAccountAuthentication

Apply account reset token to set handle and password. Basic auth will be used for new login and password. Access granted to valid reset token.

/account/auth

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
 -H "Authorization: Bearer [[accessToken]]"\
"//account/auth"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");


        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.setAccountAuthentication();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountAuthentication");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.setAccountAuthentication();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountAuthentication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance setAccountAuthenticationWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'


var api = new DataBag.AccountApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setAccountAuthentication(callback);

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

namespace Example
{
    public class setAccountAuthenticationExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                apiInstance.setAccountAuthentication();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.setAccountAuthentication: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->setAccountAuthentication();
};
if ($@) {
    warn "Exception when calling AccountApi->setAccountAuthentication: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.set_account_authentication()
except ApiException as e:
    print("Exception when calling AccountApi->setAccountAuthentication: %s\n" % e)

Parameters

Responses

Status: 201 - success

Status: 401 - permission denied

Status: 500 - internal server error

setAccountExport

Export account from node. Account is automatically disabled afterwards. Authorized to account username and password.

/account/export

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
"//account/export"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.setAccountExport();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountExport");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.setAccountExport();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountExport");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance setAccountExportWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setAccountExport(callback);

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

namespace Example
{
    public class setAccountExportExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();

            try
            {
                apiInstance.setAccountExport();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.setAccountExport: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->setAccountExport();
};
if ($@) {
    warn "Exception when calling AccountApi->setAccountExport: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.set_account_export()
except ApiException as e:
    print("Exception when calling AccountApi->setAccountExport: %s\n" % e)

Parameters

Responses

Status: 201 - success

Status: 401 - permission denied

Status: 500 - internal server error

setAccountNode

Set forwarding address after export/import has completed. Access granted to valid reset token.

/account/node

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
-H "Content-Type: application/json"\
"//account/node"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        String body = ; // String | 
        try {
            apiInstance.setAccountNode(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountNode");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var opts = { 
  'body':  // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setAccountNode(opts, callback);

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

namespace Example
{
    public class setAccountNodeExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();
            var body = new String(); // String |  (optional) 

            try
            {
                apiInstance.setAccountNode(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.setAccountNode: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // String | 

try {
    $api_instance->setAccountNode($body);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->setAccountNode: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->setAccountNode(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->setAccountNode: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # String |  (optional)

try: 
    api_instance.set_account_node(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->setAccountNode: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - success

Status: 401 - permission denied

Status: 405 - failed to confirm

Status: 500 - internal server error

setAccountSeachable

Set whether account is publicly listed.

/account/searchable

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
-H "Content-Type: application/json"\
"//account/searchable"

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

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

public class AccountApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AccountApi apiInstance = new AccountApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.setAccountSeachable(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountSeachable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.setAccountSeachable(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#setAccountSeachable");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Boolean *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AccountApi()
var opts = { 
  'body':  // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setAccountSeachable(opts, callback);

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

namespace Example
{
    public class setAccountSeachableExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AccountApi();
            var body = new Boolean(); // Boolean |  (optional) 

            try
            {
                apiInstance.setAccountSeachable(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.setAccountSeachable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // Boolean | 

try {
    $api_instance->setAccountSeachable($body);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->setAccountSeachable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->setAccountSeachable(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->setAccountSeachable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # Boolean |  (optional)

try: 
    api_instance.set_account_seachable(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->setAccountSeachable: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - success

Status: 401 - permission denied

Status: 405 - failed to confirm

Status: 500 - internal server error

Admin

addNodeAccount

Gernerate a url for creating a new account. Access granted to admin username and password.

/admin/accounts

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//admin/accounts"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

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

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class addNodeAccountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();

            try
            {
                'String' result = apiInstance.addNodeAccount();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.addNodeAccount: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.add_node_account()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->addNodeAccount: %s\n" % e)

Parameters

Responses

Status: 201 - success

Schema

Status: 401 - invalid password

Status: 500 - internal server error

getNodeAccountImage

Get profile image of specified account. Access granted to admin username and password

/admin/accounts/{accountId}/image

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/octet-stream"\
"//admin/accounts/{accountId}/image"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of specified account
        try {
            byte[] result = apiInstance.getNodeAccountImage(accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#getNodeAccountImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of specified account
        try {
            byte[] result = apiInstance.getNodeAccountImage(accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#getNodeAccountImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *accountId = accountId_example; // id of specified account

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

[apiInstance getNodeAccountImageWith:accountId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var accountId = accountId_example; // {{String}} id of specified account

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

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

namespace Example
{
    public class getNodeAccountImageExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();
            var accountId = accountId_example;  // String | id of specified account

            try
            {
                byte[] result = apiInstance.getNodeAccountImage(accountId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.getNodeAccountImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAdminApi();
$accountId = accountId_example; // String | id of specified account

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $accountId = accountId_example; # String | id of specified account

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AdminApi()
accountId = accountId_example # String | id of specified account

try: 
    api_response = api_instance.get_node_account_image(accountId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->getNodeAccountImage: %s\n" % e)

Parameters

Path parameters

Name	Description
accountId*	String id of specified account Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 405 - invalid image

Status: 500 - internal server error

getNodeAccounts

Get list of accounts hosted on node. Access granted to admin username and password.

/admin/accounts

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//admin/accounts"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

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

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getNodeAccountsWithCompletionHandler: 
              ^(array[Account] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getNodeAccountsExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();

            try
            {
                array[Account] result = apiInstance.getNodeAccounts();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.getNodeAccounts: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_node_accounts()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->getNodeAccounts: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation

Schema

Status: 401 - invalid password

Status: 404 - handle not found

Status: 500 - internal server error

getNodeConfig

Get node configuration. Access granted to admin username and password.

/admin/config

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//admin/config"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        try {
            NodeConfig result = apiInstance.getNodeConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#getNodeConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getNodeConfigWithCompletionHandler: 
              ^(NodeConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

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

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

namespace Example
{
    public class getNodeConfigExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();

            try
            {
                NodeConfig result = apiInstance.getNodeConfig();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.getNodeConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.get_node_config()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->getNodeConfig: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 500 - internal server error

getNodeStatus

Check if portal params have been set

/admin/status

Usage and SDK Samples

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

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

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

public class AdminApiExample {

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

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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


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

[apiInstance getNodeStatusWithCompletionHandler: 
              ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');

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

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

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

            var apiInstance = new AdminApi();

            try
            {
                'Boolean' result = apiInstance.getNodeStatus();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.getNodeStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try: 
    api_response = api_instance.get_node_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->getNodeStatus: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 500 - internal server error

import_account

Import an account account from a backup archive. Access granted to the admin username and password.

/admin/accounts/import

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Content-Type: multipart/form-data"\
"//admin/accounts/import"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.import_account(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#import_account");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        byte[] fileName = fileName_example; // byte[] | 
        try {
            apiInstance.import_account(fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#import_account");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
byte[] *fileName = fileName_example; //  (optional)

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

[apiInstance import_accountWith:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var opts = { 
  'fileName': fileName_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.import_account(opts, callback);

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

namespace Example
{
    public class import_accountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();
            var fileName = fileName_example;  // byte[] |  (optional) 

            try
            {
                apiInstance.import_account(fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.import_account: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAdminApi();
$fileName = fileName_example; // byte[] | 

try {
    $api_instance->import_account($fileName);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->import_account: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $fileName = fileName_example; # byte[] | 

eval { 
    $api_instance->import_account(fileName => $fileName);
};
if ($@) {
    warn "Exception when calling AdminApi->import_account: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AdminApi()
fileName = fileName_example # byte[] |  (optional)

try: 
    api_instance.import_account(fileName=fileName)
except ApiException as e:
    print("Exception when calling AdminApi->import_account: %s\n" % e)

Parameters

Form parameters

Name	Description
fileName	byte[] (binary)

Responses

Status: 201 - success

Status: 401 - permission denied

Status: 406 - account already imported

Status: 500 - internal server error

removeNodeAccount

Remove account from node. Access granted to admin username and password.

/admin/accounts/{accountId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Basic [[basicHash]]"\
"//admin/accounts/{accountId}"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of account to delete
        try {
            apiInstance.removeNodeAccount(accountId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#removeNodeAccount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of account to delete
        try {
            apiInstance.removeNodeAccount(accountId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#removeNodeAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *accountId = accountId_example; // id of account to delete

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

[apiInstance removeNodeAccountWith:accountId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var accountId = accountId_example; // {{String}} id of account to delete

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

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

namespace Example
{
    public class removeNodeAccountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();
            var accountId = accountId_example;  // String | id of account to delete

            try
            {
                apiInstance.removeNodeAccount(accountId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.removeNodeAccount: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAdminApi();
$accountId = accountId_example; // String | id of account to delete

try {
    $api_instance->removeNodeAccount($accountId);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->removeNodeAccount: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $accountId = accountId_example; # String | id of account to delete

eval { 
    $api_instance->removeNodeAccount(accountId => $accountId);
};
if ($@) {
    warn "Exception when calling AdminApi->removeNodeAccount: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AdminApi()
accountId = accountId_example # String | id of account to delete

try: 
    api_instance.remove_node_account(accountId)
except ApiException as e:
    print("Exception when calling AdminApi->removeNodeAccount: %s\n" % e)

Parameters

Path parameters

Name	Description
accountId*	String id of account to delete Required

Responses

Status: 200 - successful operation

Status: 401 - invalid authentication

Status: 404 - account not found

Status: 500 - internal server error

setNodeAccount

Generate a password reset url for specified account. Access granted to admin username and password.

/admin/accounts/{accountId}/reset

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"//admin/accounts/{accountId}/reset"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of profile to access
        try {
            'String' result = apiInstance.setNodeAccount(accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeAccount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String accountId = accountId_example; // String | id of profile to access
        try {
            'String' result = apiInstance.setNodeAccount(accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *accountId = accountId_example; // id of profile to access

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

[apiInstance setNodeAccountWith:accountId
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var accountId = accountId_example; // {{String}} id of profile to access

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

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

namespace Example
{
    public class setNodeAccountExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();
            var accountId = accountId_example;  // String | id of profile to access

            try
            {
                'String' result = apiInstance.setNodeAccount(accountId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.setNodeAccount: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAdminApi();
$accountId = accountId_example; // String | id of profile to access

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $accountId = accountId_example; # String | id of profile to access

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AdminApi()
accountId = accountId_example # String | id of profile to access

try: 
    api_response = api_instance.set_node_account(accountId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->setNodeAccount: %s\n" % e)

Parameters

Path parameters

Name	Description
accountId*	String id of profile to access Required

Responses

Status: 201 - success

Schema

Status: 401 - invalid password

Status: 404 - unknown portal

Status: 500 - internal server error

setNodeConfig

Set node config. Access granted to admin username and password.

/admin/config

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
"//admin/config"

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        try {
            apiInstance.setNodeConfig();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        try {
            apiInstance.setNodeConfig();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeConfig");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance setNodeConfigWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setNodeConfig(callback);

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

namespace Example
{
    public class setNodeConfigExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();

            try
            {
                apiInstance.setNodeConfig();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.setNodeConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->setNodeConfig();
};
if ($@) {
    warn "Exception when calling AdminApi->setNodeConfig: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.set_node_config()
except ApiException as e:
    print("Exception when calling AdminApi->setNodeConfig: %s\n" % e)

Parameters

Responses

Status: 200 - success

Status: 401 - permission denide

Status: 500 - internal server error

setNodeStatus

Set admin password and node domain

/admin/status

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Basic [[basicHash]]"\
"//admin/status?domain="

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

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

public class AdminApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: basicCredentials
        HttpBasicAuth basicCredentials = (HttpBasicAuth) defaultClient.getAuthentication("basicCredentials");
        basicCredentials.setUsername("YOUR USERNAME");
        basicCredentials.setPassword("YOUR PASSWORD");

        AdminApi apiInstance = new AdminApi();
        String domain = domain_example; // String | domain of node
        try {
            apiInstance.setNodeStatus(domain);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String domain = domain_example; // String | domain of node
        try {
            apiInstance.setNodeStatus(domain);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setNodeStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicCredentials)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *domain = domain_example; // domain of node

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

[apiInstance setNodeStatusWith:domain
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;
// Configure HTTP basic authorization: basicCredentials
var basicCredentials = defaultClient.authentications['basicCredentials'];
basicCredentials.username = 'YOUR USERNAME'
basicCredentials.password = 'YOUR PASSWORD'

var api = new DataBag.AdminApi()
var domain = domain_example; // {{String}} domain of node

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

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

namespace Example
{
    public class setNodeStatusExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicCredentials
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new AdminApi();
            var domain = domain_example;  // String | domain of node

            try
            {
                apiInstance.setNodeStatus(domain);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.setNodeStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicCredentials
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiAdminApi();
$domain = domain_example; // String | domain of node

try {
    $api_instance->setNodeStatus($domain);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->setNodeStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdminApi;
# Configure HTTP basic authorization: basicCredentials
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $domain = domain_example; # String | domain of node

eval { 
    $api_instance->setNodeStatus(domain => $domain);
};
if ($@) {
    warn "Exception when calling AdminApi->setNodeStatus: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basicCredentials
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AdminApi()
domain = domain_example # String | domain of node

try: 
    api_instance.set_node_status(domain)
except ApiException as e:
    print("Exception when calling AdminApi->setNodeStatus: %s\n" % e)

Parameters

Query parameters

Name	Description
domain*	String domain of node Required

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 500 - internal server error

Alias

addGroup

Add a group for sharing. Access granted to app tokens of account holder.

/alias/groups

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//alias/groups"

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

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

public class AliasApiExample {

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


        AliasApi apiInstance = new AliasApi();
        Subject body = ; // Subject | 
        try {
            Group result = apiInstance.addGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#addGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AliasApi;

public class AliasApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Subject *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AliasApi()
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addGroup(opts, callback);

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

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


            var apiInstance = new AliasApi();
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                Group result = apiInstance.addGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.addGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAliasApi();
$body = ; // Subject | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.AliasApi()
body =  # Subject |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

getGroupSubjectField

Base64 decode and download specified field from the groups's subject. Access granted to app token of account holder.

/alias/groups/{groupId}/subject/{field}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//alias/groups/{groupId}/subject/{field}"

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

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

public class AliasApiExample {

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


        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getGroupSubjectField(groupId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#getGroupSubjectField");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getGroupSubjectField(groupId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#getGroupSubjectField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *groupId = groupId_example; // specified group id
String *field = field_example; // field from subject to base64 decode and download

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

[apiInstance getGroupSubjectFieldWith:groupId
    field:field
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AliasApi()
var groupId = groupId_example; // {{String}} specified group id
var field = field_example; // {{String}} field from subject to base64 decode and download

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

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

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


            var apiInstance = new AliasApi();
            var groupId = groupId_example;  // String | specified group id
            var field = field_example;  // String | field from subject to base64 decode and download

            try
            {
                byte[] result = apiInstance.getGroupSubjectField(groupId, field);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.getGroupSubjectField: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAliasApi();
$groupId = groupId_example; // String | specified group id
$field = field_example; // String | field from subject to base64 decode and download

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

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


my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $groupId = groupId_example; # String | specified group id
my $field = field_example; # String | field from subject to base64 decode and download

eval { 
    my $result = $api_instance->getGroupSubjectField(groupId => $groupId, field => $field);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AliasApi->getGroupSubjectField: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AliasApi()
groupId = groupId_example # String | specified group id
field = field_example # String | field from subject to base64 decode and download

try: 
    api_response = api_instance.get_group_subject_field(groupId, field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AliasApi->getGroupSubjectField: %s\n" % e)

Parameters

Path parameters

Name	Description
groupId*	String specified group id Required
field*	String field from subject to base64 decode and download Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - field, article not found

Status: 405 - invalid field

Status: 410 - account disabled

Status: 500 - internal server error

getGroups

Get groups for sharing. Access granted to app tokens of the account holder.

/alias/groups

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//alias/groups"

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

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

public class AliasApiExample {

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


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

import io.swagger.client.api.AliasApi;

public class AliasApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

[apiInstance getGroupsWithCompletionHandler: 
              ^(array[Group] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


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

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

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


            var apiInstance = new AliasApi();

            try
            {
                array[Group] result = apiInstance.getGroups();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.getGroups: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    api_response = api_instance.get_groups()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AliasApi->getGroups: %s\n" % e)

Parameters

Responses

Name	Type	Format	Description
X-Group-Revision	Long	int64

Status: 401 - invalid token

Status: 410 - account disabled

Status: 500 - internal server error

removeGroup

Remove sharing group

/alias/groups/{groupId}/subject

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//alias/groups/{groupId}/subject"

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

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

public class AliasApiExample {

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


        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        try {
            apiInstance.removeGroup(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#removeGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        try {
            apiInstance.removeGroup(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#removeGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *groupId = groupId_example; // specified group id

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

[apiInstance removeGroupWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AliasApi()
var groupId = groupId_example; // {{String}} specified group id

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

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

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


            var apiInstance = new AliasApi();
            var groupId = groupId_example;  // String | specified group id

            try
            {
                apiInstance.removeGroup(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.removeGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAliasApi();
$groupId = groupId_example; // String | specified group id

try {
    $api_instance->removeGroup($groupId);
} catch (Exception $e) {
    echo 'Exception when calling AliasApi->removeGroup: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $groupId = groupId_example; # String | specified group id

eval { 
    $api_instance->removeGroup(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling AliasApi->removeGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AliasApi()
groupId = groupId_example # String | specified group id

try: 
    api_instance.remove_group(groupId)
except ApiException as e:
    print("Exception when calling AliasApi->removeGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
groupId*	String specified group id Required

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - group not found

Status: 410 - account disabled

Status: 500 - internal server error

setGroupSubject

Update group description for sharing. Access granted to app tokens of account holder.

/alias/groups/{groupId}/subject

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//alias/groups/{groupId}/subject"

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

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

public class AliasApiExample {

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


        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        Subject body = ; // Subject | 
        try {
            Group result = apiInstance.setGroupSubject(groupId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#setGroupSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        String groupId = groupId_example; // String | specified group id
        Subject body = ; // Subject | 
        try {
            Group result = apiInstance.setGroupSubject(groupId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#setGroupSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *groupId = groupId_example; // specified group id
Subject *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AliasApi()
var groupId = groupId_example; // {{String}} specified group id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setGroupSubject(groupId, opts, callback);

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

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


            var apiInstance = new AliasApi();
            var groupId = groupId_example;  // String | specified group id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                Group result = apiInstance.setGroupSubject(groupId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.setGroupSubject: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAliasApi();
$groupId = groupId_example; // String | specified group id
$body = ; // Subject | 

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

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


my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $groupId = groupId_example; # String | specified group id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

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

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


# create an instance of the API class
api_instance = swagger_client.AliasApi()
groupId = groupId_example # String | specified group id
body =  # Subject |  (optional)

try: 
    api_response = api_instance.set_group_subject(groupId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AliasApi->setGroupSubject: %s\n" % e)

Parameters

Path parameters

Name	Description
groupId*	String specified group id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - group not found

Status: 410 - account disabled

Status: 500 - internal server error

Attribute

addArticle

Add a content article. Access granted to app token of the account holder.

/attribute/articles

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//attribute/articles"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        Subject body = ; // Subject | 
        try {
            Article result = apiInstance.addArticle(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#addArticle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
Subject *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addArticle(opts, callback);

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

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


            var apiInstance = new AttributeApi();
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                Article result = apiInstance.addArticle(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.addArticle: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$body = ; // Subject | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
body =  # Subject |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - entry created

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

clearArticleGroup

Clear sharing group for article. Access granted to app tokens for account holder.

/attribute/articles/{articleId}/groups/{groupId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//attribute/articles/{articleId}/groups/{groupId}"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            Article result = apiInstance.clearArticleGroup(articleId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#clearArticleGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            Article result = apiInstance.clearArticleGroup(articleId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#clearArticleGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *articleId = articleId_example; // specified card id
String *groupId = groupId_example; // specified share id

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

[apiInstance clearArticleGroupWith:articleId
    groupId:groupId
              completionHandler: ^(Article output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var articleId = articleId_example; // {{String}} specified card id
var groupId = groupId_example; // {{String}} specified share id

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

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

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


            var apiInstance = new AttributeApi();
            var articleId = articleId_example;  // String | specified card id
            var groupId = groupId_example;  // String | specified share id

            try
            {
                Article result = apiInstance.clearArticleGroup(articleId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.clearArticleGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$articleId = articleId_example; // String | specified card id
$groupId = groupId_example; // String | specified share id

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

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $articleId = articleId_example; # String | specified card id
my $groupId = groupId_example; # String | specified share id

eval { 
    my $result = $api_instance->clearArticleGroup(articleId => $articleId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AttributeApi->clearArticleGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
articleId = articleId_example # String | specified card id
groupId = groupId_example # String | specified share id

try: 
    api_response = api_instance.clear_article_group(articleId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AttributeApi->clearArticleGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
articleId*	String specified card id Required
groupId*	String specified share id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

getArticleSubjectField

Base64 decode and download specified field from the article's subject. Access granted to app token of account holder or contact token of account the article is shared with.

/attribute/articles/{articleId}/subject/{field}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//attribute/articles/{articleId}/subject/{field}"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getArticleSubjectField(articleId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#getArticleSubjectField");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getArticleSubjectField(articleId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#getArticleSubjectField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *articleId = articleId_example; // specified article id
String *field = field_example; // field from subject to base64 decode and download

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

[apiInstance getArticleSubjectFieldWith:articleId
    field:field
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var articleId = articleId_example; // {{String}} specified article id
var field = field_example; // {{String}} field from subject to base64 decode and download

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

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

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


            var apiInstance = new AttributeApi();
            var articleId = articleId_example;  // String | specified article id
            var field = field_example;  // String | field from subject to base64 decode and download

            try
            {
                byte[] result = apiInstance.getArticleSubjectField(articleId, field);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.getArticleSubjectField: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$articleId = articleId_example; // String | specified article id
$field = field_example; // String | field from subject to base64 decode and download

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

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $articleId = articleId_example; # String | specified article id
my $field = field_example; # String | field from subject to base64 decode and download

eval { 
    my $result = $api_instance->getArticleSubjectField(articleId => $articleId, field => $field);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AttributeApi->getArticleSubjectField: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
articleId = articleId_example # String | specified article id
field = field_example # String | field from subject to base64 decode and download

try: 
    api_response = api_instance.get_article_subject_field(articleId, field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AttributeApi->getArticleSubjectField: %s\n" % e)

Parameters

Path parameters

Name	Description
articleId*	String specified article id Required
field*	String field from subject to base64 decode and download Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - field, article not found

Status: 405 - invalid field

Status: 410 - account disabled

Status: 500 - internal server error

getArticles

Get article slots that should be updated based on revisions. Access granted to account token or contact token. When the request is made with a contact token the account view revision will be added to the block revision.

/attribute/articles

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//attribute/articles?viewRevision=&articleRevision=&types="

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String viewRevision = viewRevision_example; // String | view revision from which attribute revision applies
        String articleRevision = articleRevision_example; // String | return updated articles since revision
        String types = types_example; // String | return only articles of specified types
        try {
            array[Article] result = apiInstance.getArticles(viewRevision, articleRevision, types);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#getArticles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String viewRevision = viewRevision_example; // String | view revision from which attribute revision applies
        String articleRevision = articleRevision_example; // String | return updated articles since revision
        String types = types_example; // String | return only articles of specified types
        try {
            array[Article] result = apiInstance.getArticles(viewRevision, articleRevision, types);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#getArticles");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *viewRevision = viewRevision_example; // view revision from which attribute revision applies (optional)
String *articleRevision = articleRevision_example; // return updated articles since revision (optional)
String *types = types_example; // return only articles of specified types (optional)

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

[apiInstance getArticlesWith:viewRevision
    articleRevision:articleRevision
    types:types
              completionHandler: ^(array[Article] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var opts = { 
  'viewRevision': viewRevision_example, // {{String}} view revision from which attribute revision applies
  'articleRevision': articleRevision_example, // {{String}} return updated articles since revision
  'types': types_example // {{String}} return only articles of specified types
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getArticles(opts, callback);

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

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


            var apiInstance = new AttributeApi();
            var viewRevision = viewRevision_example;  // String | view revision from which attribute revision applies (optional) 
            var articleRevision = articleRevision_example;  // String | return updated articles since revision (optional) 
            var types = types_example;  // String | return only articles of specified types (optional) 

            try
            {
                array[Article] result = apiInstance.getArticles(viewRevision, articleRevision, types);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.getArticles: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$viewRevision = viewRevision_example; // String | view revision from which attribute revision applies
$articleRevision = articleRevision_example; // String | return updated articles since revision
$types = types_example; // String | return only articles of specified types

try {
    $result = $api_instance->getArticles($viewRevision, $articleRevision, $types);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AttributeApi->getArticles: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $viewRevision = viewRevision_example; # String | view revision from which attribute revision applies
my $articleRevision = articleRevision_example; # String | return updated articles since revision
my $types = types_example; # String | return only articles of specified types

eval { 
    my $result = $api_instance->getArticles(viewRevision => $viewRevision, articleRevision => $articleRevision, types => $types);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AttributeApi->getArticles: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
viewRevision = viewRevision_example # String | view revision from which attribute revision applies (optional)
articleRevision = articleRevision_example # String | return updated articles since revision (optional)
types = types_example # String | return only articles of specified types (optional)

try: 
    api_response = api_instance.get_articles(viewRevision=viewRevision, articleRevision=articleRevision, types=types)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AttributeApi->getArticles: %s\n" % e)

Parameters

Query parameters

Name	Description
viewRevision	String view revision from which attribute revision applies
articleRevision	String return updated articles since revision
types	String return only articles of specified types

Responses

Status: 200 - successful operation

Schema
Headers

Name	Type	Format	Description
X-View-Revision	Long	int64
X-Article-Revision	Long	int64

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

removeArticle

Remove specified article. Access granted to app token of account holder.

/attribute/articles/{articleId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//attribute/articles/{articleId}"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        try {
            apiInstance.removeArticle(articleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#removeArticle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        try {
            apiInstance.removeArticle(articleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#removeArticle");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *articleId = articleId_example; // specified article id

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

[apiInstance removeArticleWith:articleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var articleId = articleId_example; // {{String}} specified article id

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

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

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


            var apiInstance = new AttributeApi();
            var articleId = articleId_example;  // String | specified article id

            try
            {
                apiInstance.removeArticle(articleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.removeArticle: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$articleId = articleId_example; // String | specified article id

try {
    $api_instance->removeArticle($articleId);
} catch (Exception $e) {
    echo 'Exception when calling AttributeApi->removeArticle: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $articleId = articleId_example; # String | specified article id

eval { 
    $api_instance->removeArticle(articleId => $articleId);
};
if ($@) {
    warn "Exception when calling AttributeApi->removeArticle: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
articleId = articleId_example # String | specified article id

try: 
    api_instance.remove_article(articleId)
except ApiException as e:
    print("Exception when calling AttributeApi->removeArticle: %s\n" % e)

Parameters

Path parameters

Name	Description
articleId*	String specified article id Required

Responses

Status: 200 - success

Status: 401 - invalid password

Status: 404 - article not found

Status: 410 - account disabled

Status: 500 - internal server error

setArticleGroup

Set group for articles. Access granted to app tokens for account holder.

/attribute/articles/{articleId}/groups/{groupId}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//attribute/articles/{articleId}/groups/{groupId}"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        String groupId = groupId_example; // String | specified group id
        try {
            Article result = apiInstance.setArticleGroup(articleId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#setArticleGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        String groupId = groupId_example; // String | specified group id
        try {
            Article result = apiInstance.setArticleGroup(articleId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#setArticleGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *articleId = articleId_example; // specified article id
String *groupId = groupId_example; // specified group id

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

[apiInstance setArticleGroupWith:articleId
    groupId:groupId
              completionHandler: ^(Article output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var articleId = articleId_example; // {{String}} specified article id
var groupId = groupId_example; // {{String}} specified group id

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

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

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


            var apiInstance = new AttributeApi();
            var articleId = articleId_example;  // String | specified article id
            var groupId = groupId_example;  // String | specified group id

            try
            {
                Article result = apiInstance.setArticleGroup(articleId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.setArticleGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$articleId = articleId_example; // String | specified article id
$groupId = groupId_example; // String | specified group id

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

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $articleId = articleId_example; # String | specified article id
my $groupId = groupId_example; # String | specified group id

eval { 
    my $result = $api_instance->setArticleGroup(articleId => $articleId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AttributeApi->setArticleGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
articleId = articleId_example # String | specified article id
groupId = groupId_example # String | specified group id

try: 
    api_response = api_instance.set_article_group(articleId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AttributeApi->setArticleGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
articleId*	String specified article id Required
groupId*	String specified group id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

setArticleSubject

Set subject for article. Access granted to app token of account holder.

/attribute/articles/{articleId}/subject

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//attribute/articles/{articleId}/subject"

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

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

public class AttributeApiExample {

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


        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        Subject body = ; // Subject | 
        try {
            apiInstance.setArticleSubject(articleId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#setArticleSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AttributeApi;

public class AttributeApiExample {

    public static void main(String[] args) {
        AttributeApi apiInstance = new AttributeApi();
        String articleId = articleId_example; // String | specified article id
        Subject body = ; // Subject | 
        try {
            apiInstance.setArticleSubject(articleId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AttributeApi#setArticleSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *articleId = articleId_example; // specified article id
Subject *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AttributeApi()
var articleId = articleId_example; // {{String}} specified article id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setArticleSubject(articleId, opts, callback);

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

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


            var apiInstance = new AttributeApi();
            var articleId = articleId_example;  // String | specified article id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                apiInstance.setArticleSubject(articleId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AttributeApi.setArticleSubject: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAttributeApi();
$articleId = articleId_example; // String | specified article id
$body = ; // Subject | 

try {
    $api_instance->setArticleSubject($articleId, $body);
} catch (Exception $e) {
    echo 'Exception when calling AttributeApi->setArticleSubject: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AttributeApi->new();
my $articleId = articleId_example; # String | specified article id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

eval { 
    $api_instance->setArticleSubject(articleId => $articleId, body => $body);
};
if ($@) {
    warn "Exception when calling AttributeApi->setArticleSubject: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AttributeApi()
articleId = articleId_example # String | specified article id
body =  # Subject |  (optional)

try: 
    api_instance.set_article_subject(articleId, body=body)
except ApiException as e:
    print("Exception when calling AttributeApi->setArticleSubject: %s\n" % e)

Parameters

Path parameters

Name	Description
articleId*	String specified article id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - article not found

Status: 410 - account disabled

Status: 500 - internal server error

Authorize

authorize

Retrieve an authenticate data messaging verifying the account holder is accepting the action referenced by the token.

/authorize

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//authorize"

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

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

public class AuthorizeApiExample {

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


        AuthorizeApi apiInstance = new AuthorizeApi();
        String body = ; // String | 
        try {
            DataMessage result = apiInstance.authorize(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizeApi#authorize");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuthorizeApi;

public class AuthorizeApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
String *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.AuthorizeApi()
var opts = { 
  'body':  // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authorize(opts, callback);

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

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


            var apiInstance = new AuthorizeApi();
            var body = new String(); // String |  (optional) 

            try
            {
                DataMessage result = apiInstance.authorize(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthorizeApi.authorize: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthorizeApi();
$body = ; // String | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.AuthorizeApi()
body =  # String |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

Contact

addCard

Add a contact card. Access granted to app tokens of account holder.

/contact/cards

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        try {
            DataMessage result = apiInstance.addCard();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#addCard");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

[apiInstance addCardWithCompletionHandler: 
              ^(DataMessage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


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

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

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


            var apiInstance = new ContactApi();

            try
            {
                DataMessage result = apiInstance.addCard();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.addCard: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    api_response = api_instance.add_card()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->addCard: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 400 - invalid data message

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

clearCardGroup

Clear sharing group for card. Access granted to app tokens for account holder.

/contact/cards/{cardId}/groups/{groupId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/groups/{groupId}"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            CardDetail result = apiInstance.clearCardGroup(cardId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#clearCardGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            CardDetail result = apiInstance.clearCardGroup(cardId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#clearCardGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id
String *groupId = groupId_example; // specified share id

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

[apiInstance clearCardGroupWith:cardId
    groupId:groupId
              completionHandler: ^(CardDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id
var groupId = groupId_example; // {{String}} specified share id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id
            var groupId = groupId_example;  // String | specified share id

            try
            {
                CardDetail result = apiInstance.clearCardGroup(cardId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.clearCardGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id
$groupId = groupId_example; // String | specified share id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id
my $groupId = groupId_example; # String | specified share id

eval { 
    my $result = $api_instance->clearCardGroup(cardId => $cardId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContactApi->clearCardGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id
groupId = groupId_example # String | specified share id

try: 
    api_response = api_instance.clear_card_group(cardId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->clearCardGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required
groupId*	String specified share id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

clearCardNotes

Clear notes for specified card. Access granted to app tokens of account holder.

/contact/cards/{cardId}/notes

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/notes"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardDetail result = apiInstance.clearCardNotes(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#clearCardNotes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardDetail result = apiInstance.clearCardNotes(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#clearCardNotes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance clearCardNotesWith:cardId
              completionHandler: ^(CardDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                CardDetail result = apiInstance.clearCardNotes(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.clearCardNotes: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.clear_card_notes(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->clearCardNotes: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

getCardDetail

Get specified card detail. Access granted to app tokens for account holder.

/contact/cards/{cardId}/detail

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/detail"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardDetail result = apiInstance.getCardDetail(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardDetail");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardDetail result = apiInstance.getCardDetail(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardDetail");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance getCardDetailWith:cardId
              completionHandler: ^(CardDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                CardDetail result = apiInstance.getCardDetail(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getCardDetail: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.get_card_detail(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getCardDetail: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

getCardProfile

Get profile of card entry. Access granted to app tokens of account holder.

/contact/cards/{cardId}/profile

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/profile"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardProfile result = apiInstance.getCardProfile(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            CardProfile result = apiInstance.getCardProfile(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardProfile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance getCardProfileWith:cardId
              completionHandler: ^(CardProfile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                CardProfile result = apiInstance.getCardProfile(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getCardProfile: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.get_card_profile(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getCardProfile: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - successful operation

Schema

Status: 401 - permission denied

Status: 404 - not found

Status: 410 - account disabled

Status: 500 - internal server error

getCardProfileImage

Get image of card profile. Access granted to app tokens of account holder.

/contact/cards/{cardId}/profile/image

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/octet-stream"\
"//contact/cards/{cardId}/profile/image"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            byte[] result = apiInstance.getCardProfileImage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardProfileImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            byte[] result = apiInstance.getCardProfileImage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCardProfileImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance getCardProfileImageWith:cardId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                byte[] result = apiInstance.getCardProfileImage(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getCardProfileImage: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.get_card_profile_image(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getCardProfileImage: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 405 - invalid image

Status: 410 - account disabled

Status: 500 - internal server error

getCards

Get list of cards. Access granted to app tokens of account holder.

/contact/cards

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards?revision="

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String revision = revision_example; // String | only return updated cards since specified revision
        try {
            array[Card] result = apiInstance.getCards(revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCards");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String revision = revision_example; // String | only return updated cards since specified revision
        try {
            array[Card] result = apiInstance.getCards(revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCards");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *revision = revision_example; // only return updated cards since specified revision (optional)

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

[apiInstance getCardsWith:revision
              completionHandler: ^(array[Card] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var opts = { 
  'revision': revision_example // {{String}} only return updated cards since specified revision
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCards(opts, callback);

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

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


            var apiInstance = new ContactApi();
            var revision = revision_example;  // String | only return updated cards since specified revision (optional) 

            try
            {
                array[Card] result = apiInstance.getCards(revision);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getCards: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$revision = revision_example; // String | only return updated cards since specified revision

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $revision = revision_example; # String | only return updated cards since specified revision

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
revision = revision_example # String | only return updated cards since specified revision (optional)

try: 
    api_response = api_instance.get_cards(revision=revision)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getCards: %s\n" % e)

Parameters

Query parameters

Name	Description
revision	String only return updated cards since specified revision

Responses

Status: 200 - successful operation

Schema
Headers

Name	Type	Format	Description
X-Card-Revision	Long	int64

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

getCloseMessage

Get message for closing connection with contact. Access granted to app tokens for account holder.

/contact/cards/{cardId}/closeMessage

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/closeMessage"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            DataMessage result = apiInstance.getCloseMessage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCloseMessage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            DataMessage result = apiInstance.getCloseMessage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getCloseMessage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance getCloseMessageWith:cardId
              completionHandler: ^(DataMessage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                DataMessage result = apiInstance.getCloseMessage(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getCloseMessage: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.get_close_message(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getCloseMessage: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - successful operation

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

getOpenMessage

Get message for connecting to other contacts. Access granted to app tokens for account holder.

/contact/cards/{cardId}/openMessage

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/openMessage"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            DataMessage result = apiInstance.getOpenMessage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getOpenMessage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            DataMessage result = apiInstance.getOpenMessage(cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#getOpenMessage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance getOpenMessageWith:cardId
              completionHandler: ^(DataMessage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                DataMessage result = apiInstance.getOpenMessage(cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.getOpenMessage: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.get_open_message(cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->getOpenMessage: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

removeCard

Remove card entry. Access granted to app tokens of account holder.

/contact/cards/{cardId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//contact/cards/{cardId}"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            apiInstance.removeCard(cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#removeCard");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        try {
            apiInstance.removeCard(cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#removeCard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id

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

[apiInstance removeCardWith:cardId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id

            try
            {
                apiInstance.removeCard(cardId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.removeCard: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id

try {
    $api_instance->removeCard($cardId);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->removeCard: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id

eval { 
    $api_instance->removeCard(cardId => $cardId);
};
if ($@) {
    warn "Exception when calling ContactApi->removeCard: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id

try: 
    api_instance.remove_card(cardId)
except ApiException as e:
    print("Exception when calling ContactApi->removeCard: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

setArticleRevision

Set artcile revision for contact. This is intend to be invoked automatically anytime a contact updates their content or sharing. Access granted to contact tokens.

/contact/article/revision

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//contact/article/revision"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setArticleRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setArticleRevision");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setArticleRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setArticleRevision");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{Long}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setArticleRevision(opts, callback);

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

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


            var apiInstance = new ContactApi();
            var body = new Long(); // Long |  (optional) 

            try
            {
                apiInstance.setArticleRevision(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setArticleRevision: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // Long | 

try {
    $api_instance->setArticleRevision($body);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setArticleRevision: ', $e->getMessage(), PHP_EOL;
}
?>

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


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

eval { 
    $api_instance->setArticleRevision(body => $body);
};
if ($@) {
    warn "Exception when calling ContactApi->setArticleRevision: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # Long |  (optional)

try: 
    api_instance.set_article_revision(body=body)
except ApiException as e:
    print("Exception when calling ContactApi->setArticleRevision: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - revision set

Status: 401 - not authorized

Status: 410 - account disabled

Status: 500 - internal server error

setCardGroup

Set sharing group for contact. Access granted to app tokens for account holder.

/contact/cards/{cardId}/groups/{groupId}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//contact/cards/{cardId}/groups/{groupId}"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String groupId = groupId_example; // String | specified group id
        try {
            CardDetail result = apiInstance.setCardGroup(cardId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String groupId = groupId_example; // String | specified group id
        try {
            CardDetail result = apiInstance.setCardGroup(cardId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id
String *groupId = groupId_example; // specified group id

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

[apiInstance setCardGroupWith:cardId
    groupId:groupId
              completionHandler: ^(CardDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id
var groupId = groupId_example; // {{String}} specified group id

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

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id
            var groupId = groupId_example;  // String | specified group id

            try
            {
                CardDetail result = apiInstance.setCardGroup(cardId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setCardGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id
$groupId = groupId_example; // String | specified group id

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id
my $groupId = groupId_example; # String | specified group id

eval { 
    my $result = $api_instance->setCardGroup(cardId => $cardId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContactApi->setCardGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id
groupId = groupId_example # String | specified group id

try: 
    api_response = api_instance.set_card_group(cardId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->setCardGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required
groupId*	String specified group id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

setCardNotes

Update card notes for specified card. Access granted to app tokens for account holder.

/contact/cards/{cardId}/notes

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//contact/cards/{cardId}/notes"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String body = ; // String | 
        try {
            CardDetail result = apiInstance.setCardNotes(cardId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardNotes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String body = ; // String | 
        try {
            CardDetail result = apiInstance.setCardNotes(cardId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardNotes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id
String *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id
var opts = { 
  'body':  // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setCardNotes(cardId, opts, callback);

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id
            var body = new String(); // String |  (optional) 

            try
            {
                CardDetail result = apiInstance.setCardNotes(cardId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setCardNotes: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id
$body = ; // String | 

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id
body =  # String |  (optional)

try: 
    api_response = api_instance.set_card_notes(cardId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->setCardNotes: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

setCardProfile

Set profile of card entry. Access granted to app tokens of account holder.

/contact/cards/{cardId}/profile

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//contact/cards/{cardId}/profile"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        Profile body = ; // Profile | 
        try {
            DataMessage result = apiInstance.setCardProfile(cardId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        Profile body = ; // Profile | 
        try {
            DataMessage result = apiInstance.setCardProfile(cardId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardProfile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id
Profile *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id
var opts = { 
  'body':  // {{Profile}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setCardProfile(cardId, opts, callback);

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id
            var body = new Profile(); // Profile |  (optional) 

            try
            {
                DataMessage result = apiInstance.setCardProfile(cardId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setCardProfile: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id
$body = ; // Profile | 

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

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id
my $body = WWW::SwaggerClient::Object::Profile->new(); # Profile | 

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

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id
body =  # Profile |  (optional)

try: 
    api_response = api_instance.set_card_profile(cardId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->setCardProfile: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

setCardStatus

Updated connected status of contact. Access granted to app tokens of account holder.

/contact/cards/{cardId}/status

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//contact/cards/{cardId}/status?token=&profileRevision=&articleRevision=&channelRevision=&viewRevision="

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String body = ; // String | 
        String token = token_example; // String | token for accessing card
        String profileRevision = profileRevision_example; // String | profile revision of contact
        String articleRevision = articleRevision_example; // String | article revision of contact
        String channelRevision = channelRevision_example; // String | channel revision of contact
        String viewRevision = viewRevision_example; // String | view revision of contact
        try {
            CardDetail result = apiInstance.setCardStatus(cardId, body, token, profileRevision, articleRevision, channelRevision, viewRevision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        String cardId = cardId_example; // String | specified card id
        String body = ; // String | 
        String token = token_example; // String | token for accessing card
        String profileRevision = profileRevision_example; // String | profile revision of contact
        String articleRevision = articleRevision_example; // String | article revision of contact
        String channelRevision = channelRevision_example; // String | channel revision of contact
        String viewRevision = viewRevision_example; // String | view revision of contact
        try {
            CardDetail result = apiInstance.setCardStatus(cardId, body, token, profileRevision, articleRevision, channelRevision, viewRevision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCardStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *cardId = cardId_example; // specified card id
String *body = ; //  (optional)
String *token = token_example; // token for accessing card (optional)
String *profileRevision = profileRevision_example; // profile revision of contact (optional)
String *articleRevision = articleRevision_example; // article revision of contact (optional)
String *channelRevision = channelRevision_example; // channel revision of contact (optional)
String *viewRevision = viewRevision_example; // view revision of contact (optional)

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

[apiInstance setCardStatusWith:cardId
    body:body
    token:token
    profileRevision:profileRevision
    articleRevision:articleRevision
    channelRevision:channelRevision
    viewRevision:viewRevision
              completionHandler: ^(CardDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var cardId = cardId_example; // {{String}} specified card id
var opts = { 
  'body':  // {{String}} 
  'token': token_example // {{String}} token for accessing card
  'profileRevision': profileRevision_example // {{String}} profile revision of contact
  'articleRevision': articleRevision_example // {{String}} article revision of contact
  'channelRevision': channelRevision_example // {{String}} channel revision of contact
  'viewRevision': viewRevision_example // {{String}} view revision of contact
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setCardStatus(cardId, opts, callback);

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

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


            var apiInstance = new ContactApi();
            var cardId = cardId_example;  // String | specified card id
            var body = new String(); // String |  (optional) 
            var token = token_example;  // String | token for accessing card (optional) 
            var profileRevision = profileRevision_example;  // String | profile revision of contact (optional) 
            var articleRevision = articleRevision_example;  // String | article revision of contact (optional) 
            var channelRevision = channelRevision_example;  // String | channel revision of contact (optional) 
            var viewRevision = viewRevision_example;  // String | view revision of contact (optional) 

            try
            {
                CardDetail result = apiInstance.setCardStatus(cardId, body, token, profileRevision, articleRevision, channelRevision, viewRevision);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setCardStatus: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$cardId = cardId_example; // String | specified card id
$body = ; // String | 
$token = token_example; // String | token for accessing card
$profileRevision = profileRevision_example; // String | profile revision of contact
$articleRevision = articleRevision_example; // String | article revision of contact
$channelRevision = channelRevision_example; // String | channel revision of contact
$viewRevision = viewRevision_example; // String | view revision of contact

try {
    $result = $api_instance->setCardStatus($cardId, $body, $token, $profileRevision, $articleRevision, $channelRevision, $viewRevision);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setCardStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::ContactApi->new();
my $cardId = cardId_example; # String | specified card id
my $body = WWW::SwaggerClient::Object::String->new(); # String | 
my $token = token_example; # String | token for accessing card
my $profileRevision = profileRevision_example; # String | profile revision of contact
my $articleRevision = articleRevision_example; # String | article revision of contact
my $channelRevision = channelRevision_example; # String | channel revision of contact
my $viewRevision = viewRevision_example; # String | view revision of contact

eval { 
    my $result = $api_instance->setCardStatus(cardId => $cardId, body => $body, token => $token, profileRevision => $profileRevision, articleRevision => $articleRevision, channelRevision => $channelRevision, viewRevision => $viewRevision);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContactApi->setCardStatus: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
cardId = cardId_example # String | specified card id
body =  # String |  (optional)
token = token_example # String | token for accessing card (optional)
profileRevision = profileRevision_example # String | profile revision of contact (optional)
articleRevision = articleRevision_example # String | article revision of contact (optional)
channelRevision = channelRevision_example # String | channel revision of contact (optional)
viewRevision = viewRevision_example # String | view revision of contact (optional)

try: 
    api_response = api_instance.set_card_status(cardId, body=body, token=token, profileRevision=profileRevision, articleRevision=articleRevision, channelRevision=channelRevision, viewRevision=viewRevision)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactApi->setCardStatus: %s\n" % e)

Parameters

Path parameters

Name	Description
cardId*	String specified card id Required

Body parameters

Name	Description
body

Query parameters

Name	Description
token	String token for accessing card
profileRevision	String profile revision of contact
articleRevision	String article revision of contact
channelRevision	String channel revision of contact
viewRevision	String view revision of contact

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelRevision

Set channel revision for contact. This is intend to be invoked automatically anytime a contact updates their content or sharing. Access granted to contact tokens.

/contact/channel/revision

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//contact/channel/revision"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setChannelRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setChannelRevision");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setChannelRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setChannelRevision");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{Long}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setChannelRevision(opts, callback);

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

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


            var apiInstance = new ContactApi();
            var body = new Long(); // Long |  (optional) 

            try
            {
                apiInstance.setChannelRevision(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setChannelRevision: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // Long | 

try {
    $api_instance->setChannelRevision($body);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setChannelRevision: ', $e->getMessage(), PHP_EOL;
}
?>

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


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

eval { 
    $api_instance->setChannelRevision(body => $body);
};
if ($@) {
    warn "Exception when calling ContactApi->setChannelRevision: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # Long |  (optional)

try: 
    api_instance.set_channel_revision(body=body)
except ApiException as e:
    print("Exception when calling ContactApi->setChannelRevision: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - revision set

Status: 401 - not authorized

Status: 410 - account disabled

Status: 500 - internal server error

setCloseMessage

Set message for closing card connection. Access granted to public.

/contact/closeMessage

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"//contact/closeMessage"

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

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

public class ContactApiExample {

    public static void main(String[] args) {
        
        ContactApi apiInstance = new ContactApi();
        DataMessage body = ; // DataMessage | 
        try {
            apiInstance.setCloseMessage(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCloseMessage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        DataMessage body = ; // DataMessage | 
        try {
            apiInstance.setCloseMessage(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setCloseMessage");
            e.printStackTrace();
        }
    }
}

DataMessage *body = ; //  (optional)

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

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

var DataBag = require('data_bag');

var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{DataMessage}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setCloseMessage(opts, callback);

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

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

            var apiInstance = new ContactApi();
            var body = new DataMessage(); // DataMessage |  (optional) 

            try
            {
                apiInstance.setCloseMessage(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setCloseMessage: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // DataMessage | 

try {
    $api_instance->setCloseMessage($body);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setCloseMessage: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval { 
    $api_instance->setCloseMessage(body => $body);
};
if ($@) {
    warn "Exception when calling ContactApi->setCloseMessage: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # DataMessage |  (optional)

try: 
    api_instance.set_close_message(body=body)
except ApiException as e:
    print("Exception when calling ContactApi->setCloseMessage: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - successful operation

Status: 400 - invalid data message

Status: 410 - account disabled

Status: 500 - internal server error

setOpenMessage

Set message for connecting to a contact. If card has not already been added, the card will be created in the pending state. Access granted to public.

/contact/openMessage

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//contact/openMessage"

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

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

public class ContactApiExample {

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

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

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

DataMessage *body = ; //  (optional)

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

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

var DataBag = require('data_bag');

var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{DataMessage}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setOpenMessage(opts, callback);

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

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

            var apiInstance = new ContactApi();
            var body = new DataMessage(); // DataMessage |  (optional) 

            try
            {
                ContactStatus result = apiInstance.setOpenMessage(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setOpenMessage: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // DataMessage | 

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # DataMessage |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - successful operation

Schema

Status: 400 - invalid data message

Status: 410 - account disabled

Status: 500 - internal server error

setProfileRevision

Set profile revision for contact. This is intend to be invoked automatically anytime a contact updates their profile. Access granted to contact tokens.

/contact/profile/revision

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//contact/profile/revision"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setProfileRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setProfileRevision");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setProfileRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setProfileRevision");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{Long}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setProfileRevision(opts, callback);

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

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


            var apiInstance = new ContactApi();
            var body = new Long(); // Long |  (optional) 

            try
            {
                apiInstance.setProfileRevision(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setProfileRevision: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // Long | 

try {
    $api_instance->setProfileRevision($body);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setProfileRevision: ', $e->getMessage(), PHP_EOL;
}
?>

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


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

eval { 
    $api_instance->setProfileRevision(body => $body);
};
if ($@) {
    warn "Exception when calling ContactApi->setProfileRevision: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # Long |  (optional)

try: 
    api_instance.set_profile_revision(body=body)
except ApiException as e:
    print("Exception when calling ContactApi->setProfileRevision: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - revision set

Status: 401 - not authorized

Status: 410 - account disabled

Status: 500 - internal server error

setViewRevision

Set view revision for contact. This is intend to be invoked automatically anytime a contact updates their content or sharing. Access granted to contact tokens.

/contact/view/revision

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//contact/view/revision"

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

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

public class ContactApiExample {

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


        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setViewRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setViewRevision");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContactApi;

public class ContactApiExample {

    public static void main(String[] args) {
        ContactApi apiInstance = new ContactApi();
        Long body = ; // Long | 
        try {
            apiInstance.setViewRevision(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactApi#setViewRevision");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Long *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContactApi()
var opts = { 
  'body':  // {{Long}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setViewRevision(opts, callback);

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

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


            var apiInstance = new ContactApi();
            var body = new Long(); // Long |  (optional) 

            try
            {
                apiInstance.setViewRevision(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactApi.setViewRevision: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContactApi();
$body = ; // Long | 

try {
    $api_instance->setViewRevision($body);
} catch (Exception $e) {
    echo 'Exception when calling ContactApi->setViewRevision: ', $e->getMessage(), PHP_EOL;
}
?>

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


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

eval { 
    $api_instance->setViewRevision(body => $body);
};
if ($@) {
    warn "Exception when calling ContactApi->setViewRevision: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContactApi()
body =  # Long |  (optional)

try: 
    api_instance.set_view_revision(body=body)
except ApiException as e:
    print("Exception when calling ContactApi->setViewRevision: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - revision set

Status: 401 - not authorized

Status: 410 - account disabled

Status: 500 - internal server error

Content

addChannel

Add a channel.

/content/channels

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//content/channels"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        ChannelParams body = ; // ChannelParams | 
        try {
            Channel result = apiInstance.addChannel(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
ChannelParams *body = ; //  (optional)

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

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

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var opts = { 
  'body':  // {{ChannelParams}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addChannel(opts, callback);

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

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


            var apiInstance = new ContentApi();
            var body = new ChannelParams(); // ChannelParams |  (optional) 

            try
            {
                Channel result = apiInstance.addChannel(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.addChannel: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$body = ; // ChannelParams | 

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

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


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

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

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
body =  # ChannelParams |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - entry created

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

addChannelTopic

Add a topic to channel channel.

/content/channels/{channelId}/topics

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/topics?confirm="

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        Subject body = ; // Subject | 
        Boolean confirm = true; // Boolean | set if intial state is confirmed
        try {
            Topic result = apiInstance.addChannelTopic(channelId, body, confirm);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopic");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        Subject body = ; // Subject | 
        Boolean confirm = true; // Boolean | set if intial state is confirmed
        try {
            Topic result = apiInstance.addChannelTopic(channelId, body, confirm);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopic");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
Subject *body = ; //  (optional)
Boolean *confirm = true; // set if intial state is confirmed (optional)

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

[apiInstance addChannelTopicWith:channelId
    body:body
    confirm:confirm
              completionHandler: ^(Topic output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var opts = { 
  'body':  // {{Subject}} 
  'confirm': true // {{Boolean}} set if intial state is confirmed
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addChannelTopic(channelId, opts, callback);

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var body = new Subject(); // Subject |  (optional) 
            var confirm = true;  // Boolean | set if intial state is confirmed (optional) 

            try
            {
                Topic result = apiInstance.addChannelTopic(channelId, body, confirm);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.addChannelTopic: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$body = ; // Subject | 
$confirm = true; // Boolean | set if intial state is confirmed

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 
my $confirm = true; # Boolean | set if intial state is confirmed

eval { 
    my $result = $api_instance->addChannelTopic(channelId => $channelId, body => $body, confirm => $confirm);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->addChannelTopic: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
body =  # Subject |  (optional)
confirm = true # Boolean | set if intial state is confirmed (optional)

try: 
    api_response = api_instance.add_channel_topic(channelId, body=body, confirm=confirm)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->addChannelTopic: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required

Body parameters

Name	Description
body

Query parameters

Name	Description
confirm	Boolean set if intial state is confirmed

Responses

Status: 201 - entry created

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

addChannelTopicAsset

Add an an asset to the to an channel. The original posted asset is referenced in the asset list with a null transform. The transformed assets are referenced accordingly. Transforming the asset strips it of metadata and transcodes it into a specified format. Access is granted to the app token of the account holder.

/content/channels/{channelId}/topics/{topicId}/assets

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"//content/channels/{channelId}/topics/{topicId}/assets?transforms="

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        byte[] fileName = fileName_example; // byte[] | 
        array[String] transforms = ; // array[String] | transforms to apply
        try {
            array[Asset] result = apiInstance.addChannelTopicAsset(channelId, topicId, fileName, transforms);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        byte[] fileName = fileName_example; // byte[] | 
        array[String] transforms = ; // array[String] | transforms to apply
        try {
            array[Asset] result = apiInstance.addChannelTopicAsset(channelId, topicId, fileName, transforms);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
byte[] *fileName = fileName_example; //  (optional)
array[String] *transforms = ; // transforms to apply (optional)

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

[apiInstance addChannelTopicAssetWith:channelId
    topicId:topicId
    fileName:fileName
    transforms:transforms
              completionHandler: ^(array[Asset] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var opts = { 
  'fileName': fileName_example // {{byte[]}} 
  'transforms':  // {{array[String]}} transforms to apply
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addChannelTopicAsset(channelIdtopicId, opts, callback);

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var fileName = fileName_example;  // byte[] |  (optional) 
            var transforms = new array[String](); // array[String] | transforms to apply (optional) 

            try
            {
                array[Asset] result = apiInstance.addChannelTopicAsset(channelId, topicId, fileName, transforms);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.addChannelTopicAsset: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$fileName = fileName_example; // byte[] | 
$transforms = ; // array[String] | transforms to apply

try {
    $result = $api_instance->addChannelTopicAsset($channelId, $topicId, $fileName, $transforms);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->addChannelTopicAsset: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $fileName = fileName_example; # byte[] | 
my $transforms = []; # array[String] | transforms to apply

eval { 
    my $result = $api_instance->addChannelTopicAsset(channelId => $channelId, topicId => $topicId, fileName => $fileName, transforms => $transforms);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->addChannelTopicAsset: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
fileName = fileName_example # byte[] |  (optional)
transforms =  # array[String] | transforms to apply (optional)

try: 
    api_response = api_instance.add_channel_topic_asset(channelId, topicId, fileName=fileName, transforms=transforms)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->addChannelTopicAsset: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Form parameters

Name	Description
fileName	byte[] (binary)

Query parameters

Name	Description
transforms	array[String] transforms to apply

Responses

Status: 201 - success

Schema

Status: 401 - permission denied

Status: 404 - channel not found

Status: 406 - storage limit reached

Status: 410 - account disabled

Status: 500 - internal server error

addChannelTopicTag

Add a tag to channel topic.

/content/channels/{channelId}/topics/{topicId}/tags

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/topics/{topicId}/tags"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Subject body = ; // Subject | 
        try {
            Tag result = apiInstance.addChannelTopicTag(channelId, topicId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopicTag");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Subject body = ; // Subject | 
        try {
            Tag result = apiInstance.addChannelTopicTag(channelId, topicId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#addChannelTopicTag");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
Subject *body = ; //  (optional)

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

[apiInstance addChannelTopicTagWith:channelId
    topicId:topicId
    body:body
              completionHandler: ^(Tag output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addChannelTopicTag(channelIdtopicId, opts, callback);

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                Tag result = apiInstance.addChannelTopicTag(channelId, topicId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.addChannelTopicTag: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$body = ; // Subject | 

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

eval { 
    my $result = $api_instance->addChannelTopicTag(channelId => $channelId, topicId => $topicId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->addChannelTopicTag: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
body =  # Subject |  (optional)

try: 
    api_response = api_instance.add_channel_topic_tag(channelId, topicId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->addChannelTopicTag: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Body parameters

Name	Description
body

Responses

Status: 201 - entry created

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

clearChannelCard

Clear write access to channel for card. Access granted to app tokens for account holder.

/content/channels/{channelId}/cards/{cardId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/cards/{cardId}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String cardId = cardId_example; // String | specified card id
        try {
            Channel result = apiInstance.clearChannelCard(channelId, cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#clearChannelCard");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String cardId = cardId_example; // String | specified card id
        try {
            Channel result = apiInstance.clearChannelCard(channelId, cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#clearChannelCard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *cardId = cardId_example; // specified card id

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

[apiInstance clearChannelCardWith:channelId
    cardId:cardId
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var cardId = cardId_example; // {{String}} specified card id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var cardId = cardId_example;  // String | specified card id

            try
            {
                Channel result = apiInstance.clearChannelCard(channelId, cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.clearChannelCard: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$cardId = cardId_example; // String | specified card id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $cardId = cardId_example; # String | specified card id

eval { 
    my $result = $api_instance->clearChannelCard(channelId => $channelId, cardId => $cardId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->clearChannelCard: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.clear_channel_card(channelId, cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->clearChannelCard: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

clearChannelGroup

Clear read access to channel for group. Access granted to app tokens for account holder.

/content/channels/{channelId}/groups/{groupId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/groups/{groupId}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            Channel result = apiInstance.clearChannelGroup(channelId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#clearChannelGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified card id
        String groupId = groupId_example; // String | specified share id
        try {
            Channel result = apiInstance.clearChannelGroup(channelId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#clearChannelGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified card id
String *groupId = groupId_example; // specified share id

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

[apiInstance clearChannelGroupWith:channelId
    groupId:groupId
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified card id
var groupId = groupId_example; // {{String}} specified share id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified card id
            var groupId = groupId_example;  // String | specified share id

            try
            {
                Channel result = apiInstance.clearChannelGroup(channelId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.clearChannelGroup: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified card id
$groupId = groupId_example; // String | specified share id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified card id
my $groupId = groupId_example; # String | specified share id

eval { 
    my $result = $api_instance->clearChannelGroup(channelId => $channelId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->clearChannelGroup: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified card id
groupId = groupId_example # String | specified share id

try: 
    api_response = api_instance.clear_channel_group(channelId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->clearChannelGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified card id Required
groupId*	String specified share id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

getChannel

Get details of channel.

/content/channels/{channelId}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        try {
            Channel result = apiInstance.getChannel(channelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        try {
            Channel result = apiInstance.getChannel(channelId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannel");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id

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

[apiInstance getChannelWith:channelId
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id

            try
            {
                Channel result = apiInstance.getChannel(channelId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannel: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id

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

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id

try: 
    api_response = api_instance.get_channel(channelId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannel: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required

Responses

Status: 200 - success

Schema

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

getChannelSubjectField

Base64 decode and download specified field from the channel's subject. Access granted to app token of account holder or contact token of account the channel is shared with.

/content/channels/{channelId}/subject/{field}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/subject/{field}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelSubjectField(channelId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelSubjectField");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelSubjectField(channelId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelSubjectField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *field = field_example; // field from subject to base64 decode and download

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

[apiInstance getChannelSubjectFieldWith:channelId
    field:field
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var field = field_example; // {{String}} field from subject to base64 decode and download

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var field = field_example;  // String | field from subject to base64 decode and download

            try
            {
                byte[] result = apiInstance.getChannelSubjectField(channelId, field);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelSubjectField: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$field = field_example; // String | field from subject to base64 decode and download

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $field = field_example; # String | field from subject to base64 decode and download

eval { 
    my $result = $api_instance->getChannelSubjectField(channelId => $channelId, field => $field);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelSubjectField: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
field = field_example # String | field from subject to base64 decode and download

try: 
    api_response = api_instance.get_channel_subject_field(channelId, field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelSubjectField: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
field*	String field from subject to base64 decode and download Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - field, channel not found

Status: 405 - invalid field

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopic

Get full object of topic.

/content/channels/{channelId}/topics/{topicId}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            Topic result = apiInstance.getChannelTopic(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopic");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            Topic result = apiInstance.getChannelTopic(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopic");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id

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

[apiInstance getChannelTopicWith:channelId
    topicId:topicId
              completionHandler: ^(Topic output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id

            try
            {
                Topic result = apiInstance.getChannelTopic(channelId, topicId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopic: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id

eval { 
    my $result = $api_instance->getChannelTopic(channelId => $channelId, topicId => $topicId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopic: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id

try: 
    api_response = api_instance.get_channel_topic(channelId, topicId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopic: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Responses

Status: 200 - success

Schema

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicAsset

Get asset assigned to an channel. The endpoint supports byte-range requests and responds with the content-type set appropriatly. Access granted to the app tokens of the account holder and in the case of non-original assets, the contact token for accounts with which the channel is shared.

/content/channels/{channelId}/topics/{topicId}/assets/{assetId}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/octet-stream"\
"//content/channels/{channelId}/topics/{topicId}/assets/{assetId}"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String assetId = assetId_example; // String | specified asset id
        try {
            byte[] result = apiInstance.getChannelTopicAsset(channelId, topicId, assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String assetId = assetId_example; // String | specified asset id
        try {
            byte[] result = apiInstance.getChannelTopicAsset(channelId, topicId, assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *assetId = assetId_example; // specified asset id

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

[apiInstance getChannelTopicAssetWith:channelId
    topicId:topicId
    assetId:assetId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var assetId = assetId_example; // {{String}} specified asset id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var assetId = assetId_example;  // String | specified asset id

            try
            {
                byte[] result = apiInstance.getChannelTopicAsset(channelId, topicId, assetId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicAsset: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$assetId = assetId_example; // String | specified asset id

try {
    $result = $api_instance->getChannelTopicAsset($channelId, $topicId, $assetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannelTopicAsset: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $assetId = assetId_example; # String | specified asset id

eval { 
    my $result = $api_instance->getChannelTopicAsset(channelId => $channelId, topicId => $topicId, assetId => $assetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicAsset: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
assetId = assetId_example # String | specified asset id

try: 
    api_response = api_instance.get_channel_topic_asset(channelId, topicId, assetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicAsset: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
assetId*	String specified asset id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - asset or channel not found

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicAssets

Get list of assets assigned to an channel. The original assets will only be available to the account holder to provent the accidental sharing of content metadata. Access is granted to the app token of the account holder and the contact token of accounts the channel has been shared with.

/content/channels/{channelId}/topics/{topicId}/assets

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}/assets"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            array[Asset] result = apiInstance.getChannelTopicAssets(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicAssets");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            array[Asset] result = apiInstance.getChannelTopicAssets(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicAssets");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id

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

[apiInstance getChannelTopicAssetsWith:channelId
    topicId:topicId
              completionHandler: ^(array[Asset] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id

            try
            {
                array[Asset] result = apiInstance.getChannelTopicAssets(channelId, topicId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicAssets: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id

eval { 
    my $result = $api_instance->getChannelTopicAssets(channelId => $channelId, topicId => $topicId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicAssets: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id

try: 
    api_response = api_instance.get_channel_topic_assets(channelId, topicId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicAssets: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Responses

Status: 201 - entry created

Schema

Status: 401 - invalid token

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicDetail

Get detail object of topic.

/content/channels/{channelId}/topics/{topicId}/detail

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}/detail"

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

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

public class ContentApiExample {

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


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            TopicDetail result = apiInstance.getChannelTopicDetail(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicDetail");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            TopicDetail result = apiInstance.getChannelTopicDetail(channelId, topicId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicDetail");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id

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

[apiInstance getChannelTopicDetailWith:channelId
    topicId:topicId
              completionHandler: ^(TopicDetail output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id

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

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

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


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id

            try
            {
                TopicDetail result = apiInstance.getChannelTopicDetail(channelId, topicId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicDetail: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id

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

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


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id

eval { 
    my $result = $api_instance->getChannelTopicDetail(channelId => $channelId, topicId => $topicId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicDetail: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id

try: 
    api_response = api_instance.get_channel_topic_detail(channelId, topicId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicDetail: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Responses

Status: 200 - success

Schema

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicSubjectField

Base64 decode and download specified field from the channel's subject. Access granted to app token of account holder or contact token of account the channel is shared with.

/content/channels/{channelId}/topics/{topicId}/subject/{field}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}/subject/{field}"

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

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

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelTopicSubjectField(channelId, topicId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicSubjectField");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelTopicSubjectField(channelId, topicId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicSubjectField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *field = field_example; // field from subject to base64 decode and download

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance getChannelTopicSubjectFieldWith:channelId
    topicId:topicId
    field:field
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var field = field_example; // {{String}} field from subject to base64 decode and download

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannelTopicSubjectField(channelId, topicId, field, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getChannelTopicSubjectFieldExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var field = field_example;  // String | field from subject to base64 decode and download

            try
            {
                byte[] result = apiInstance.getChannelTopicSubjectField(channelId, topicId, field);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicSubjectField: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$field = field_example; // String | field from subject to base64 decode and download

try {
    $result = $api_instance->getChannelTopicSubjectField($channelId, $topicId, $field);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannelTopicSubjectField: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $field = field_example; # String | field from subject to base64 decode and download

eval { 
    my $result = $api_instance->getChannelTopicSubjectField(channelId => $channelId, topicId => $topicId, field => $field);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicSubjectField: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
field = field_example # String | field from subject to base64 decode and download

try: 
    api_response = api_instance.get_channel_topic_subject_field(channelId, topicId, field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicSubjectField: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
field*	String field from subject to base64 decode and download Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - field, channel not found

Status: 405 - invalid field

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicTagSubjectField

Base64 decode and download specified field from the channel's subject. Access granted to app token of account holder or contact token of account the channel is shared with.

/content/channels/{channelId}/topics/{topicId}/tags/{tagId}/subject/{field}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}/tags/{tagId}/subject/{field}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelTopicTagSubjectField(channelId, topicId, tagId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicTagSubjectField");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        String field = field_example; // String | field from subject to base64 decode and download
        try {
            byte[] result = apiInstance.getChannelTopicTagSubjectField(channelId, topicId, tagId, field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicTagSubjectField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *tagId = tagId_example; // specified tag id
String *field = field_example; // field from subject to base64 decode and download

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance getChannelTopicTagSubjectFieldWith:channelId
    topicId:topicId
    tagId:tagId
    field:field
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var tagId = tagId_example; // {{String}} specified tag id
var field = field_example; // {{String}} field from subject to base64 decode and download

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannelTopicTagSubjectField(channelId, topicId, tagId, field, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getChannelTopicTagSubjectFieldExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var tagId = tagId_example;  // String | specified tag id
            var field = field_example;  // String | field from subject to base64 decode and download

            try
            {
                byte[] result = apiInstance.getChannelTopicTagSubjectField(channelId, topicId, tagId, field);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicTagSubjectField: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$tagId = tagId_example; // String | specified tag id
$field = field_example; // String | field from subject to base64 decode and download

try {
    $result = $api_instance->getChannelTopicTagSubjectField($channelId, $topicId, $tagId, $field);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannelTopicTagSubjectField: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $tagId = tagId_example; # String | specified tag id
my $field = field_example; # String | field from subject to base64 decode and download

eval { 
    my $result = $api_instance->getChannelTopicTagSubjectField(channelId => $channelId, topicId => $topicId, tagId => $tagId, field => $field);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicTagSubjectField: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
tagId = tagId_example # String | specified tag id
field = field_example # String | field from subject to base64 decode and download

try: 
    api_response = api_instance.get_channel_topic_tag_subject_field(channelId, topicId, tagId, field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicTagSubjectField: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
tagId*	String specified tag id Required
field*	String field from subject to base64 decode and download Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - field, channel not found

Status: 405 - invalid field

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopicTags

Get channel topic tag slots.

/content/channels/{channelId}/topics/{topicId}/tags

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics/{topicId}/tags?revision="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String revision = revision_example; // String | return updated topics since revision
        try {
            array[Tag] result = apiInstance.getChannelTopicTags(channelId, topicId, revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicTags");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String revision = revision_example; // String | return updated topics since revision
        try {
            array[Tag] result = apiInstance.getChannelTopicTags(channelId, topicId, revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopicTags");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *revision = revision_example; // return updated topics since revision (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance getChannelTopicTagsWith:channelId
    topicId:topicId
    revision:revision
              completionHandler: ^(array[Tag] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var opts = { 
  'revision': revision_example // {{String}} return updated topics since revision
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannelTopicTags(channelId, topicId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getChannelTopicTagsExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var revision = revision_example;  // String | return updated topics since revision (optional) 

            try
            {
                array[Tag] result = apiInstance.getChannelTopicTags(channelId, topicId, revision);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopicTags: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$revision = revision_example; // String | return updated topics since revision

try {
    $result = $api_instance->getChannelTopicTags($channelId, $topicId, $revision);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannelTopicTags: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $revision = revision_example; # String | return updated topics since revision

eval { 
    my $result = $api_instance->getChannelTopicTags(channelId => $channelId, topicId => $topicId, revision => $revision);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopicTags: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
revision = revision_example # String | return updated topics since revision (optional)

try: 
    api_response = api_instance.get_channel_topic_tags(channelId, topicId, revision=revision)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopicTags: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Query parameters

Name	Description
revision	String return updated topics since revision

Responses

Status: 200 - successful operation

Schema
Headers

Name	Type	Format	Description
X-Tag-Revision	Long	int64

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

getChannelTopics

Get channel topic slots. If revision set, detail fields omitted in response

/content/channels/{channelId}/topics

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/topics?revision="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String revision = revision_example; // String | return updated topics since revision
        try {
            array[Topic] result = apiInstance.getChannelTopics(channelId, revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String revision = revision_example; // String | return updated topics since revision
        try {
            array[Topic] result = apiInstance.getChannelTopics(channelId, revision);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannelTopics");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *revision = revision_example; // return updated topics since revision (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance getChannelTopicsWith:channelId
    revision:revision
              completionHandler: ^(array[Topic] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var opts = { 
  'revision': revision_example // {{String}} return updated topics since revision
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannelTopics(channelId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getChannelTopicsExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var revision = revision_example;  // String | return updated topics since revision (optional) 

            try
            {
                array[Topic] result = apiInstance.getChannelTopics(channelId, revision);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannelTopics: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$revision = revision_example; // String | return updated topics since revision

try {
    $result = $api_instance->getChannelTopics($channelId, $revision);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannelTopics: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $revision = revision_example; # String | return updated topics since revision

eval { 
    my $result = $api_instance->getChannelTopics(channelId => $channelId, revision => $revision);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannelTopics: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
revision = revision_example # String | return updated topics since revision (optional)

try: 
    api_response = api_instance.get_channel_topics(channelId, revision=revision)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannelTopics: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required

Query parameters

Name	Description
revision	String return updated topics since revision

Responses

Status: 200 - successful operation

Schema
Headers

Name	Type	Format	Description
X-Topic-Revision	Long	int64

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

getChannels

Get channel slots. If revision set detail fields omittied in response

/content/channels

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels?viewRevision=&channelRevision=&types="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String viewRevision = viewRevision_example; // String | view revision from which content revision applies
        String channelRevision = channelRevision_example; // String | return updated channels since revision
        String types = types_example; // String | return only channels of specified types
        try {
            array[Channel] result = apiInstance.getChannels(viewRevision, channelRevision, types);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannels");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String viewRevision = viewRevision_example; // String | view revision from which content revision applies
        String channelRevision = channelRevision_example; // String | return updated channels since revision
        String types = types_example; // String | return only channels of specified types
        try {
            array[Channel] result = apiInstance.getChannels(viewRevision, channelRevision, types);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#getChannels");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *viewRevision = viewRevision_example; // view revision from which content revision applies (optional)
String *channelRevision = channelRevision_example; // return updated channels since revision (optional)
String *types = types_example; // return only channels of specified types (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance getChannelsWith:viewRevision
    channelRevision:channelRevision
    types:types
              completionHandler: ^(array[Channel] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var opts = { 
  'viewRevision': viewRevision_example, // {{String}} view revision from which content revision applies
  'channelRevision': channelRevision_example, // {{String}} return updated channels since revision
  'types': types_example // {{String}} return only channels of specified types
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannels(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getChannelsExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var viewRevision = viewRevision_example;  // String | view revision from which content revision applies (optional) 
            var channelRevision = channelRevision_example;  // String | return updated channels since revision (optional) 
            var types = types_example;  // String | return only channels of specified types (optional) 

            try
            {
                array[Channel] result = apiInstance.getChannels(viewRevision, channelRevision, types);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.getChannels: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$viewRevision = viewRevision_example; // String | view revision from which content revision applies
$channelRevision = channelRevision_example; // String | return updated channels since revision
$types = types_example; // String | return only channels of specified types

try {
    $result = $api_instance->getChannels($viewRevision, $channelRevision, $types);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->getChannels: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $viewRevision = viewRevision_example; # String | view revision from which content revision applies
my $channelRevision = channelRevision_example; # String | return updated channels since revision
my $types = types_example; # String | return only channels of specified types

eval { 
    my $result = $api_instance->getChannels(viewRevision => $viewRevision, channelRevision => $channelRevision, types => $types);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->getChannels: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
viewRevision = viewRevision_example # String | view revision from which content revision applies (optional)
channelRevision = channelRevision_example # String | return updated channels since revision (optional)
types = types_example # String | return only channels of specified types (optional)

try: 
    api_response = api_instance.get_channels(viewRevision=viewRevision, channelRevision=channelRevision, types=types)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->getChannels: %s\n" % e)

Parameters

Query parameters

Name	Description
viewRevision	String view revision from which content revision applies
channelRevision	String return updated channels since revision
types	String return only channels of specified types

Responses

Status: 200 - successful operation

Schema
Headers

Name	Type	Format	Description
X-View-Revision	Long	int64
X-Channel-Revision	Long	int64

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

removeChannel

Remove specified channel. Access granted to app token of account holder.

/content/channels/{channelId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//content/channels/{channelId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        try {
            apiInstance.removeChannel(channelId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        try {
            apiInstance.removeChannel(channelId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannel");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance removeChannelWith:channelId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeChannel(channelId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeChannelExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id

            try
            {
                apiInstance.removeChannel(channelId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.removeChannel: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id

try {
    $api_instance->removeChannel($channelId);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->removeChannel: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id

eval { 
    $api_instance->removeChannel(channelId => $channelId);
};
if ($@) {
    warn "Exception when calling ContentApi->removeChannel: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id

try: 
    api_instance.remove_channel(channelId)
except ApiException as e:
    print("Exception when calling ContentApi->removeChannel: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required

Responses

Status: 200 - success

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

removeChannelTopic

Remove specified channel. Access granted to app token of account holder.

/content/channels/{channelId}/topics/{topicId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//content/channels/{channelId}/topics/{topicId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            apiInstance.removeChannelTopic(channelId, topicId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopic");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        try {
            apiInstance.removeChannelTopic(channelId, topicId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopic");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance removeChannelTopicWith:channelId
    topicId:topicId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeChannelTopic(channelId, topicId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeChannelTopicExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id

            try
            {
                apiInstance.removeChannelTopic(channelId, topicId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.removeChannelTopic: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id

try {
    $api_instance->removeChannelTopic($channelId, $topicId);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->removeChannelTopic: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id

eval { 
    $api_instance->removeChannelTopic(channelId => $channelId, topicId => $topicId);
};
if ($@) {
    warn "Exception when calling ContentApi->removeChannelTopic: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id

try: 
    api_instance.remove_channel_topic(channelId, topicId)
except ApiException as e:
    print("Exception when calling ContentApi->removeChannelTopic: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Responses

Status: 200 - success

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

removeChannelTopicAsset

Remove an asset from an channel. Access granted to app tokens of the account holder.

/content/channels/{channelId}/topics/{topicId}/assets/{assetId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//content/channels/{channelId}/topics/{topicId}/assets/{assetId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String assetId = assetId_example; // String | specified asset id
        try {
            apiInstance.removeChannelTopicAsset(channelId, topicId, assetId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String assetId = assetId_example; // String | specified asset id
        try {
            apiInstance.removeChannelTopicAsset(channelId, topicId, assetId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopicAsset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *assetId = assetId_example; // specified asset id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance removeChannelTopicAssetWith:channelId
    topicId:topicId
    assetId:assetId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var assetId = assetId_example; // {{String}} specified asset id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeChannelTopicAsset(channelId, topicId, assetId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeChannelTopicAssetExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var assetId = assetId_example;  // String | specified asset id

            try
            {
                apiInstance.removeChannelTopicAsset(channelId, topicId, assetId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.removeChannelTopicAsset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$assetId = assetId_example; // String | specified asset id

try {
    $api_instance->removeChannelTopicAsset($channelId, $topicId, $assetId);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->removeChannelTopicAsset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $assetId = assetId_example; # String | specified asset id

eval { 
    $api_instance->removeChannelTopicAsset(channelId => $channelId, topicId => $topicId, assetId => $assetId);
};
if ($@) {
    warn "Exception when calling ContentApi->removeChannelTopicAsset: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
assetId = assetId_example # String | specified asset id

try: 
    api_instance.remove_channel_topic_asset(channelId, topicId, assetId)
except ApiException as e:
    print("Exception when calling ContentApi->removeChannelTopicAsset: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
assetId*	String specified asset id Required

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - asset or channel not found

Status: 410 - account disabled

Status: 500 - internal server error

removeChannelTopicTag

Remove specified tag from channel topic. Access granted to app token of account holder.

/content/channels/{channelId}/topics/{topicId}/tags/{tagId}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
"//content/channels/{channelId}/topics/{topicId}/tags/{tagId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        try {
            apiInstance.removeChannelTopicTag(channelId, topicId, tagId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopicTag");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        try {
            apiInstance.removeChannelTopicTag(channelId, topicId, tagId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#removeChannelTopicTag");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *tagId = tagId_example; // specified tag id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance removeChannelTopicTagWith:channelId
    topicId:topicId
    tagId:tagId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var tagId = tagId_example; // {{String}} specified tag id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeChannelTopicTag(channelId, topicId, tagId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeChannelTopicTagExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var tagId = tagId_example;  // String | specified tag id

            try
            {
                apiInstance.removeChannelTopicTag(channelId, topicId, tagId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.removeChannelTopicTag: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$tagId = tagId_example; // String | specified tag id

try {
    $api_instance->removeChannelTopicTag($channelId, $topicId, $tagId);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->removeChannelTopicTag: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $tagId = tagId_example; # String | specified tag id

eval { 
    $api_instance->removeChannelTopicTag(channelId => $channelId, topicId => $topicId, tagId => $tagId);
};
if ($@) {
    warn "Exception when calling ContentApi->removeChannelTopicTag: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
tagId = tagId_example # String | specified tag id

try: 
    api_instance.remove_channel_topic_tag(channelId, topicId, tagId)
except ApiException as e:
    print("Exception when calling ContentApi->removeChannelTopicTag: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
tagId*	String specified tag id Required

Responses

Status: 200 - success

Status: 401 - invalid password

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelCard

Set card for write access to channel. Access granted to app tokens for account holder.

/content/channels/{channelId}/cards/{cardId}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/cards/{cardId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String cardId = cardId_example; // String | specified card id
        try {
            Channel result = apiInstance.setChannelCard(channelId, cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelCard");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String cardId = cardId_example; // String | specified card id
        try {
            Channel result = apiInstance.setChannelCard(channelId, cardId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelCard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *cardId = cardId_example; // specified card id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelCardWith:channelId
    cardId:cardId
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var cardId = cardId_example; // {{String}} specified card id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setChannelCard(channelId, cardId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelCardExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var cardId = cardId_example;  // String | specified card id

            try
            {
                Channel result = apiInstance.setChannelCard(channelId, cardId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelCard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$cardId = cardId_example; // String | specified card id

try {
    $result = $api_instance->setChannelCard($channelId, $cardId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelCard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $cardId = cardId_example; # String | specified card id

eval { 
    my $result = $api_instance->setChannelCard(channelId => $channelId, cardId => $cardId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelCard: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
cardId = cardId_example # String | specified card id

try: 
    api_response = api_instance.set_channel_card(channelId, cardId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelCard: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
cardId*	String specified card id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelGroup

Set group for read access to channel. Access granted to app tokens for account holder.

/content/channels/{channelId}/groups/{groupId}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//content/channels/{channelId}/groups/{groupId}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String groupId = groupId_example; // String | specified group id
        try {
            Channel result = apiInstance.setChannelGroup(channelId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String groupId = groupId_example; // String | specified group id
        try {
            Channel result = apiInstance.setChannelGroup(channelId, groupId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *groupId = groupId_example; // specified group id

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelGroupWith:channelId
    groupId:groupId
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var groupId = groupId_example; // {{String}} specified group id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setChannelGroup(channelId, groupId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelGroupExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var groupId = groupId_example;  // String | specified group id

            try
            {
                Channel result = apiInstance.setChannelGroup(channelId, groupId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$groupId = groupId_example; // String | specified group id

try {
    $result = $api_instance->setChannelGroup($channelId, $groupId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $groupId = groupId_example; # String | specified group id

eval { 
    my $result = $api_instance->setChannelGroup(channelId => $channelId, groupId => $groupId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelGroup: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
groupId = groupId_example # String | specified group id

try: 
    api_response = api_instance.set_channel_group(channelId, groupId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelGroup: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
groupId*	String specified group id Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - card or group not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelSubject

Set subject for channel. Access granted to app token of account holder.

/content/channels/{channelId}/subject

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/subject"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        Subject body = ; // Subject | 
        try {
            Channel result = apiInstance.setChannelSubject(channelId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        Subject body = ; // Subject | 
        try {
            Channel result = apiInstance.setChannelSubject(channelId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
Subject *body = ; //  (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelSubjectWith:channelId
    body:body
              completionHandler: ^(Channel output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setChannelSubject(channelId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelSubjectExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                Channel result = apiInstance.setChannelSubject(channelId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelSubject: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$body = ; // Subject | 

try {
    $result = $api_instance->setChannelSubject($channelId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelSubject: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

eval { 
    my $result = $api_instance->setChannelSubject(channelId => $channelId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelSubject: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
body =  # Subject |  (optional)

try: 
    api_response = api_instance.set_channel_subject(channelId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelSubject: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelTopicConfirmed

Set confirmed state of the channel. Until the confirmed state has been set to true, the channel will not be visible to contacts with which the channel is shared. Access granted to the app tokens of the acocunt holder.

/content/channels/{channelId}/topics/{topicId}/confirmed

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/topics/{topicId}/confirmed"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Boolean body = ; // Boolean | 
        try {
            apiInstance.setChannelTopicConfirmed(channelId, topicId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicConfirmed");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Boolean body = ; // Boolean | 
        try {
            apiInstance.setChannelTopicConfirmed(channelId, topicId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicConfirmed");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
Boolean *body = ; //  (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelTopicConfirmedWith:channelId
    topicId:topicId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var opts = { 
  'body':  // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setChannelTopicConfirmed(channelIdtopicId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelTopicConfirmedExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var body = new Boolean(); // Boolean |  (optional) 

            try
            {
                apiInstance.setChannelTopicConfirmed(channelId, topicId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelTopicConfirmed: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$body = ; // Boolean | 

try {
    $api_instance->setChannelTopicConfirmed($channelId, $topicId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelTopicConfirmed: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->setChannelTopicConfirmed(channelId => $channelId, topicId => $topicId, body => $body);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelTopicConfirmed: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
body =  # Boolean |  (optional)

try: 
    api_instance.set_channel_topic_confirmed(channelId, topicId, body=body)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelTopicConfirmed: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelTopicSubject

Set subject for channel. Access granted to app token of account holder.

/content/channels/{channelId}/topics/{topicId}/subject

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/topics/{topicId}/subject"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Subject body = ; // Subject | 
        try {
            apiInstance.setChannelTopicSubject(channelId, topicId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        Subject body = ; // Subject | 
        try {
            apiInstance.setChannelTopicSubject(channelId, topicId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
Subject *body = ; //  (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelTopicSubjectWith:channelId
    topicId:topicId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setChannelTopicSubject(channelIdtopicId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelTopicSubjectExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                apiInstance.setChannelTopicSubject(channelId, topicId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelTopicSubject: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$body = ; // Subject | 

try {
    $api_instance->setChannelTopicSubject($channelId, $topicId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelTopicSubject: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

eval { 
    $api_instance->setChannelTopicSubject(channelId => $channelId, topicId => $topicId, body => $body);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelTopicSubject: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
body =  # Subject |  (optional)

try: 
    api_instance.set_channel_topic_subject(channelId, topicId, body=body)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelTopicSubject: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

setChannelTopicTagSubject

Set subject for channel. Access granted to app token of account holder.

/content/channels/{channelId}/topics/{topicId}/tags/{tagId}/subject

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"//content/channels/{channelId}/topics/{topicId}/tags/{tagId}/subject"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContentApi;

import java.io.File;
import java.util.*;

public class ContentApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        Subject body = ; // Subject | 
        try {
            apiInstance.setChannelTopicTagSubject(channelId, topicId, tagId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicTagSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ContentApi;

public class ContentApiExample {

    public static void main(String[] args) {
        ContentApi apiInstance = new ContentApi();
        String channelId = channelId_example; // String | specified channel id
        String topicId = topicId_example; // String | specified topic id
        String tagId = tagId_example; // String | specified tag id
        Subject body = ; // Subject | 
        try {
            apiInstance.setChannelTopicTagSubject(channelId, topicId, tagId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContentApi#setChannelTopicTagSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *channelId = channelId_example; // specified channel id
String *topicId = topicId_example; // specified topic id
String *tagId = tagId_example; // specified tag id
Subject *body = ; //  (optional)

ContentApi *apiInstance = [[ContentApi alloc] init];

[apiInstance setChannelTopicTagSubjectWith:channelId
    topicId:topicId
    tagId:tagId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ContentApi()
var channelId = channelId_example; // {{String}} specified channel id
var topicId = topicId_example; // {{String}} specified topic id
var tagId = tagId_example; // {{String}} specified tag id
var opts = { 
  'body':  // {{Subject}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setChannelTopicTagSubject(channelIdtopicIdtagId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setChannelTopicTagSubjectExample
    {
        public void main()
        {


            var apiInstance = new ContentApi();
            var channelId = channelId_example;  // String | specified channel id
            var topicId = topicId_example;  // String | specified topic id
            var tagId = tagId_example;  // String | specified tag id
            var body = new Subject(); // Subject |  (optional) 

            try
            {
                apiInstance.setChannelTopicTagSubject(channelId, topicId, tagId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContentApi.setChannelTopicTagSubject: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiContentApi();
$channelId = channelId_example; // String | specified channel id
$topicId = topicId_example; // String | specified topic id
$tagId = tagId_example; // String | specified tag id
$body = ; // Subject | 

try {
    $api_instance->setChannelTopicTagSubject($channelId, $topicId, $tagId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ContentApi->setChannelTopicTagSubject: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContentApi;


my $api_instance = WWW::SwaggerClient::ContentApi->new();
my $channelId = channelId_example; # String | specified channel id
my $topicId = topicId_example; # String | specified topic id
my $tagId = tagId_example; # String | specified tag id
my $body = WWW::SwaggerClient::Object::Subject->new(); # Subject | 

eval { 
    $api_instance->setChannelTopicTagSubject(channelId => $channelId, topicId => $topicId, tagId => $tagId, body => $body);
};
if ($@) {
    warn "Exception when calling ContentApi->setChannelTopicTagSubject: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ContentApi()
channelId = channelId_example # String | specified channel id
topicId = topicId_example # String | specified topic id
tagId = tagId_example # String | specified tag id
body =  # Subject |  (optional)

try: 
    api_instance.set_channel_topic_tag_subject(channelId, topicId, tagId, body=body)
except ApiException as e:
    print("Exception when calling ContentApi->setChannelTopicTagSubject: %s\n" % e)

Parameters

Path parameters

Name	Description
channelId*	String specified channel id Required
topicId*	String specified topic id Required
tagId*	String specified tag id Required

Body parameters

Name	Description
body

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - channel not found

Status: 410 - account disabled

Status: 500 - internal server error

Profile

getProfile

Get profile of accunt. Access granted to app token of account holder.

/profile

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//profile"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ProfileApi apiInstance = new ProfileApi();
        try {
            Profile result = apiInstance.getProfile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        try {
            Profile result = apiInstance.getProfile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

ProfileApi *apiInstance = [[ProfileApi alloc] init];

[apiInstance getProfileWithCompletionHandler: 
              ^(Profile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ProfileApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProfile(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getProfileExample
    {
        public void main()
        {


            var apiInstance = new ProfileApi();

            try
            {
                Profile result = apiInstance.getProfile();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.getProfile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiProfileApi();

try {
    $result = $api_instance->getProfile();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->getProfile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProfileApi;


my $api_instance = WWW::SwaggerClient::ProfileApi->new();

eval { 
    my $result = $api_instance->getProfile();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfile: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ProfileApi()

try: 
    api_response = api_instance.get_profile()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfile: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

getProfileImage

Download base64 decoded data of profile image. Access granted to app tokens of account holder.

/profile/image

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/octet-stream"\
"//profile/image"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ProfileApi apiInstance = new ProfileApi();
        try {
            byte[] result = apiInstance.getProfileImage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        try {
            byte[] result = apiInstance.getProfileImage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

ProfileApi *apiInstance = [[ProfileApi alloc] init];

[apiInstance getProfileImageWithCompletionHandler: 
              ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ProfileApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProfileImage(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getProfileImageExample
    {
        public void main()
        {


            var apiInstance = new ProfileApi();

            try
            {
                byte[] result = apiInstance.getProfileImage();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.getProfileImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiProfileApi();

try {
    $result = $api_instance->getProfileImage();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->getProfileImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProfileApi;


my $api_instance = WWW::SwaggerClient::ProfileApi->new();

eval { 
    my $result = $api_instance->getProfileImage();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfileImage: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ProfileApi()

try: 
    api_response = api_instance.get_profile_image()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileImage: %s\n" % e)

Parameters

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 405 - invalid image

Status: 410 - account disabled

Status: 500 - internal server error

getProfileMessage

Get a profile data message. Access granted to app token of account holder or contact token of connected contact.

/profile/message

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"//profile/message"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ProfileApi apiInstance = new ProfileApi();
        String tokenType = tokenType_example; // String | 
        try {
            DataMessage result = apiInstance.getProfileMessage(tokenType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMessage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String tokenType = tokenType_example; // String | 
        try {
            DataMessage result = apiInstance.getProfileMessage(tokenType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMessage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *tokenType = tokenType_example; // 

ProfileApi *apiInstance = [[ProfileApi alloc] init];

[apiInstance getProfileMessageWith:tokenType
              completionHandler: ^(DataMessage output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ProfileApi()
var tokenType = tokenType_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProfileMessage(tokenType, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getProfileMessageExample
    {
        public void main()
        {


            var apiInstance = new ProfileApi();
            var tokenType = tokenType_example;  // String | 

            try
            {
                DataMessage result = apiInstance.getProfileMessage(tokenType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.getProfileMessage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiProfileApi();
$tokenType = tokenType_example; // String | 

try {
    $result = $api_instance->getProfileMessage($tokenType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->getProfileMessage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProfileApi;


my $api_instance = WWW::SwaggerClient::ProfileApi->new();
my $tokenType = tokenType_example; # String | 

eval { 
    my $result = $api_instance->getProfileMessage(tokenType => $tokenType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfileMessage: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ProfileApi()
tokenType = tokenType_example # String | 

try: 
    api_response = api_instance.get_profile_message(tokenType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileMessage: %s\n" % e)

Parameters

Header parameters

Name	Description
TokenType*	String Required

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

setProfile

Set profile data. Access granted to app tokens of account holder.

/profile/data

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//profile/data"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ProfileApi apiInstance = new ProfileApi();
        ProfileData body = ; // ProfileData | 
        try {
            Profile result = apiInstance.setProfile(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        ProfileData body = ; // ProfileData | 
        try {
            Profile result = apiInstance.setProfile(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
ProfileData *body = ; //  (optional)

ProfileApi *apiInstance = [[ProfileApi alloc] init];

[apiInstance setProfileWith:body
              completionHandler: ^(Profile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ProfileApi()
var opts = { 
  'body':  // {{ProfileData}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setProfile(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setProfileExample
    {
        public void main()
        {


            var apiInstance = new ProfileApi();
            var body = new ProfileData(); // ProfileData |  (optional) 

            try
            {
                Profile result = apiInstance.setProfile(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.setProfile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiProfileApi();
$body = ; // ProfileData | 

try {
    $result = $api_instance->setProfile($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->setProfile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProfileApi;


my $api_instance = WWW::SwaggerClient::ProfileApi->new();
my $body = WWW::SwaggerClient::Object::ProfileData->new(); # ProfileData | 

eval { 
    my $result = $api_instance->setProfile(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->setProfile: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ProfileApi()
body =  # ProfileData |  (optional)

try: 
    api_response = api_instance.set_profile(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->setProfile: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 410 - account disabled

Status: 500 - internal server error

setProfileImage

Set base64 encode image data for profile. Access granted to app tokens of account holder.

/profile/image

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"//profile/image"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ProfileApi apiInstance = new ProfileApi();
        String body = ; // String | 
        try {
            Profile result = apiInstance.setProfileImage(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfileImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String body = ; // String | 
        try {
            Profile result = apiInstance.setProfileImage(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfileImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *body = ; //  (optional)

ProfileApi *apiInstance = [[ProfileApi alloc] init];

[apiInstance setProfileImageWith:body
              completionHandler: ^(Profile output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');
var defaultClient = DataBag.ApiClient.instance;


var api = new DataBag.ProfileApi()
var opts = { 
  'body':  // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setProfileImage(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class setProfileImageExample
    {
        public void main()
        {


            var apiInstance = new ProfileApi();
            var body = new String(); // String |  (optional) 

            try
            {
                Profile result = apiInstance.setProfileImage(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.setProfileImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiProfileApi();
$body = ; // String | 

try {
    $result = $api_instance->setProfileImage($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->setProfileImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProfileApi;


my $api_instance = WWW::SwaggerClient::ProfileApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    my $result = $api_instance->setProfileImage(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->setProfileImage: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ProfileApi()
body =  # String |  (optional)

try: 
    api_response = api_instance.set_profile_image(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->setProfileImage: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - success

Schema

Status: 401 - permission denied

Status: 405 - invalid image

Status: 410 - account disabled

Status: 500 - internal server error

Status

status

Websocket placeholder endpoint for receiving account status updates

/status

Usage and SDK Samples

curl -X GET\
"//status"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StatusApi;

import java.io.File;
import java.util.*;

public class StatusApiExample {

    public static void main(String[] args) {
        
        StatusApi apiInstance = new StatusApi();
        try {
            apiInstance.status();
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#status");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StatusApi;

public class StatusApiExample {

    public static void main(String[] args) {
        StatusApi apiInstance = new StatusApi();
        try {
            apiInstance.status();
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#status");
            e.printStackTrace();
        }
    }
}


StatusApi *apiInstance = [[StatusApi alloc] init];

[apiInstance statusWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var DataBag = require('data_bag');

var api = new DataBag.StatusApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.status(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class statusExample
    {
        public void main()
        {

            var apiInstance = new StatusApi();

            try
            {
                apiInstance.status();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StatusApi.status: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiStatusApi();

try {
    $api_instance->status();
} catch (Exception $e) {
    echo 'Exception when calling StatusApi->status: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StatusApi;

my $api_instance = WWW::SwaggerClient::StatusApi->new();

eval { 
    $api_instance->status();
};
if ($@) {
    warn "Exception when calling StatusApi->status: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.StatusApi()

try: 
    api_instance.status()
except ApiException as e:
    print("Exception when calling StatusApi->status: %s\n" % e)

DataBag

API and SDK Documentation

Account

addAccount

Usage and SDK Samples

Parameters

Responses

Status: 201 - successful operation

Status: 400 - invalid handle or password

Status: 401 - permission denied

Status: 500 - internal server error

addAccountApp

Usage and SDK Samples

Parameters

Responses

Status: 201 - generated

Status: 401 - invalid password

Status: 410 - account disabled

Status: 500 - internal server error

addAccountAuthentication

Usage and SDK Samples

Parameters

Responses

Status: 201 - generated

Status: 401 - invalid password

Status: 500 - internal server error

getAccountApps

Usage and SDK Samples

Parameters

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 500 - internal server error

getAccountAsset

Usage and SDK Samples

Parameters

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 404 - asset or article not found

Status: 500 - internal server error

getAccountImage

Usage and SDK Samples

Parameters

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 405 - invalid image

Status: 500 - internal server error

getAccountListing

Usage and SDK Samples

Parameters

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 500 - internal server error

getAccountProfile

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

Status: 401 - authentication error

Status: 500 - internal server error

getAccountStatus

Usage and SDK Samples

Parameters

Responses

Status: 200 - successful operation

Status: 401 - authentication error

Status: 500 - internal server error

getAccountToken

Usage and SDK Samples

Parameters

Responses

Status: 200 - success

Status: 401 - permission denied

Status: 500 - internal server error

getAccountUsername

Usage and SDK Samples

Parameters