App Invite Service

Default

activeTokens

List all active tokens

List tokens that have not expired or recalled

/active

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"http://localhost:8080/active"

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

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

public class DefaultApiExample {

    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");

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

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

// List all active tokens
[apiInstance activeTokensWithCompletionHandler: 
              ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

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

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

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // List all active tokens
                Object result = apiInstance.activeTokens();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.activeTokens: " + 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\ApiDefaultApi();

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

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

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

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

try: 
    # List all active tokens
    api_response = api_instance.active_tokens()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->activeTokens: %s\n" % e)

Parameters

Responses

Name	Type	Format	Description
WWW-Authenticate	String

generate

Generate token

Generate token that can be used for validation in the Catalyst Experience App

/generate

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"http://localhost:8080/generate"

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

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

public class DefaultApiExample {

    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");

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

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

// Generate token
[apiInstance generateWithCompletionHandler: 
              ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

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

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

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // Generate token
                Object result = apiInstance.generate();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.generate: " + 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\ApiDefaultApi();

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

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

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

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

try: 
    # Generate token
    api_response = api_instance.generate()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->generate: %s\n" % e)

Parameters

Responses

Status: 200 - A JSON object containing the token

Schema

Status: 401 - A JSON object requesting the client to provide Authorization data

Schema
Headers

Name	Type	Format	Description
WWW-Authenticate	String

inactiveTokens

List all inactive tokens

List tokens that have expired/recalled

/inactive

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"http://localhost:8080/inactive"

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

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

public class DefaultApiExample {

    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");

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

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

// List all inactive tokens
[apiInstance inactiveTokensWithCompletionHandler: 
              ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

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

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

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // List all inactive tokens
                Object result = apiInstance.inactiveTokens();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.inactiveTokens: " + 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\ApiDefaultApi();

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

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

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

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

try: 
    # List all inactive tokens
    api_response = api_instance.inactive_tokens()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->inactiveTokens: %s\n" % e)

Parameters

Responses

Status: 200 - A JSON object containing an array of token objects

Schema

Status: 404 - A JSON object indicating the tokens were not found

Schema

Status: 401 - A JSON object requesting the client to provide Authorization data

Schema
Headers

Name	Type	Format	Description
WWW-Authenticate	String

recallToken

Disable a token

Disable(recall) a token

/recall/{token}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
"http://localhost:8080/recall/{token}"

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

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

public class DefaultApiExample {

    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");

        DefaultApi apiInstance = new DefaultApi();
        String token = token_example; // String | The token to be recalled
        try {
            Object result = apiInstance.recallToken(token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#recallToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String token = token_example; // String | The token to be recalled
        try {
            Object result = apiInstance.recallToken(token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#recallToken");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *token = token_example; // The token to be recalled

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

// Disable a token
[apiInstance recallTokenWith:token
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

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

var api = new AppInviteService.DefaultApi()
var token = token_example; // {{String}} The token to be recalled

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

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

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

            var apiInstance = new DefaultApi();
            var token = token_example;  // String | The token to be recalled

            try
            {
                // Disable a token
                Object result = apiInstance.recallToken(token);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.recallToken: " + 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\ApiDefaultApi();
$token = token_example; // String | The token to be recalled

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $token = token_example; # String | The token to be recalled

eval { 
    my $result = $api_instance->recallToken(token => $token);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->recallToken: $@\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.DefaultApi()
token = token_example # String | The token to be recalled

try: 
    # Disable a token
    api_response = api_instance.recall_token(token)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->recallToken: %s\n" % e)

Parameters

Path parameters

Name	Description
token*	String The token to be recalled Required

Responses

Status: 200 - A JSON object indicating success or failure

Schema

Status: 404 - A JSON object indicating the token was not found

Schema

Status: 401 - A JSON object requesting the client to provide Authorization data

Schema
Headers

Name	Type	Format	Description
WWW-Authenticate	String

validateToken

Validate token

Validate a token, it can be used to login

/validate/{token}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"http://localhost:8080/validate/{token}"

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

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        String token = token_example; // String | The token to be validated
        try {
            Object result = apiInstance.validateToken(token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String token = token_example; // String | The token to be validated
        try {
            Object result = apiInstance.validateToken(token);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#validateToken");
            e.printStackTrace();
        }
    }
}

String *token = token_example; // The token to be validated

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

// Validate token
[apiInstance validateTokenWith:token
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AppInviteService = require('app_invite_service');

var api = new AppInviteService.DefaultApi()
var token = token_example; // {{String}} The token to be validated

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

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

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

            var apiInstance = new DefaultApi();
            var token = token_example;  // String | The token to be validated

            try
            {
                // Validate token
                Object result = apiInstance.validateToken(token);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.validateToken: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiDefaultApi();
$token = token_example; // String | The token to be validated

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

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $token = token_example; # String | The token to be validated

eval { 
    my $result = $api_instance->validateToken(token => $token);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->validateToken: $@\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.DefaultApi()
token = token_example # String | The token to be validated

try: 
    # Validate token
    api_response = api_instance.validate_token(token)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->validateToken: %s\n" % e)

Parameters

Path parameters

Name	Description
token*	String The token to be validated Required

Responses

Status: 200 - A JSON object indicating success or failure

Schema

App Invite Service

API and SDK Documentation

Default

activeTokens

Usage and SDK Samples

Parameters

Responses

Status: 200 - A JSON object containing an array of token objects

Status: 404 - A JSON object indicating the tokens were not found

Status: 401 - A JSON object requesting the client to provide Authorization data

generate

Usage and SDK Samples

Parameters

Responses

Status: 200 - A JSON object containing the token

Status: 401 - A JSON object requesting the client to provide Authorization data

inactiveTokens

Usage and SDK Samples

Parameters

Responses

Status: 200 - A JSON object containing an array of token objects

Status: 404 - A JSON object indicating the tokens were not found

Status: 401 - A JSON object requesting the client to provide Authorization data

recallToken

Usage and SDK Samples

Parameters

Responses

Status: 200 - A JSON object indicating success or failure

Status: 404 - A JSON object indicating the token was not found

Status: 401 - A JSON object requesting the client to provide Authorization data

validateToken

Usage and SDK Samples

Parameters

Responses

Status: 200 - A JSON object indicating success or failure