LiveView REST API

V10

getTable

Gets the details of a specific table


/tables/{tablename}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}?include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            TableInfo result = apiInstance.getTable(tablename, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#getTable");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            TableInfo result = apiInstance.getTable(tablename, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#getTable");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

[apiInstance getTableWith:tablename
    includeInternal:includeInternal
              completionHandler: ^(TableInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                TableInfo result = apiInstance.getTable(tablename, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.getTable: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$includeInternal = true; // Boolean | Should internal fields be included

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

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->getTable(tablename => $tablename, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->getTable: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    api_response = api_instance.get_table(tablename, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->getTable: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Table details

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name


getTables

Table List

Gets a list of all tables on the server


/tables

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables?with-permission=&with-type="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
        String withType = withType_example; // String | (v1.1+) Only return tables with the given type
        try {
            array['String'] result = apiInstance.getTables(withPermission, withType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#getTables");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
        String withType = withType_example; // String | (v1.1+) Only return tables with the given type
        try {
            array['String'] result = apiInstance.getTables(withPermission, withType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#getTables");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *withPermission = withPermission_example; // (v1.1+) Only return tables with the given allowedPermission (optional)
String *withType = withType_example; // (v1.1+) Only return tables with the given type (optional) (default to all)

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

// Table List
[apiInstance getTablesWith:withPermission
    withType:withType
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var opts = { 
  'withPermission': withPermission_example, // {String} (v1.1+) Only return tables with the given allowedPermission
  'withType': withType_example // {String} (v1.1+) Only return tables with the given type
};

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

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

            var apiInstance = new V10Api();
            var withPermission = withPermission_example;  // String | (v1.1+) Only return tables with the given allowedPermission (optional) 
            var withType = withType_example;  // String | (v1.1+) Only return tables with the given type (optional)  (default to all)

            try
            {
                // Table List
                array['String'] result = apiInstance.getTables(withPermission, withType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.getTables: " + 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\Api\V10Api();
$withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
$withType = withType_example; // String | (v1.1+) Only return tables with the given type

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

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $withPermission = withPermission_example; # String | (v1.1+) Only return tables with the given allowedPermission
my $withType = withType_example; # String | (v1.1+) Only return tables with the given type

eval { 
    my $result = $api_instance->getTables(withPermission => $withPermission, withType => $withType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->getTables: $@\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.V10Api()
withPermission = withPermission_example # String | (v1.1+) Only return tables with the given allowedPermission (optional)
withType = withType_example # String | (v1.1+) Only return tables with the given type (optional) (default to all)

try: 
    # Table List
    api_response = api_instance.get_tables(withPermission=withPermission, withType=withType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->getTables: %s\n" % e)

Parameters

Query parameters
Name Description
with-permission
String
(v1.1+) Only return tables with the given allowedPermission
with-type
String
(v1.1+) Only return tables with the given type

Responses

Status: 200 - Success

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


getVersion

Version info

Gets the version of the current server


/version

Usage and SDK Samples

curl -X GET "https://localhost/lv/api/v1/version"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

    public static void main(String[] args) {
        
        V10Api apiInstance = new V10Api();
        try {
            VersionInfo result = apiInstance.getVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#getVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

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

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

// Version info
[apiInstance getVersionWithCompletionHandler: 
              ^(VersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');

var api = new LiveViewRestApi.V10Api()

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {
            
            var apiInstance = new V10Api();

            try
            {
                // Version info
                VersionInfo result = apiInstance.getVersion();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.getVersion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Version info
    api_response = api_instance.get_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->getVersion: %s\n" % e)

Parameters

Responses

Status: 200 - Successful response


issueDelete

Delete rows

Delete specified tuples on the given table, with either a query or a list of tuple's key fields


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query=&publisher-id="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string. Ignored when specific tuples provided.
        PublishData tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
        String publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)
        try {
            StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string. Ignored when specific tuples provided.
        PublishData tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
        String publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)
        try {
            StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string. Ignored when specific tuples provided. (optional)
PublishData *tuples = ; // The tuples to delete (AS_PUBLISH; works with recovery) (optional)
String *publisherId = publisherId_example; // An ID for this publisher (if AS_PUBLISH) (optional)

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

// Delete rows
[apiInstance issueDeleteWith:tablename
    query:query
    tuples:tuples
    publisherId:publisherId
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example, // {String} Query string. Ignored when specific tuples provided.
  'tuples': , // {PublishData} The tuples to delete (AS_PUBLISH; works with recovery)
  'publisherId': publisherId_example // {String} An ID for this publisher (if AS_PUBLISH)
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string. Ignored when specific tuples provided. (optional) 
            var tuples = new PublishData(); // PublishData | The tuples to delete (AS_PUBLISH; works with recovery) (optional) 
            var publisherId = publisherId_example;  // String | An ID for this publisher (if AS_PUBLISH) (optional) 

            try
            {
                // Delete rows
                StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.issueDelete: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string. Ignored when specific tuples provided.
$tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
$publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)

try {
    $result = $api_instance->issueDelete($tablename, $query, $tuples, $publisherId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V10Api->issueDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V10Api;

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string. Ignored when specific tuples provided.
my $tuples = WWW::SwaggerClient::Object::PublishData->new(); # PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
my $publisherId = publisherId_example; # String | An ID for this publisher (if AS_PUBLISH)

eval { 
    my $result = $api_instance->issueDelete(tablename => $tablename, query => $query, tuples => $tuples, publisherId => $publisherId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->issueDelete: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string. Ignored when specific tuples provided. (optional)
tuples =  # PublishData | The tuples to delete (AS_PUBLISH; works with recovery) (optional)
publisherId = publisherId_example # String | An ID for this publisher (if AS_PUBLISH) (optional)

try: 
    # Delete rows
    api_response = api_instance.issue_delete(tablename, query=query, tuples=tuples, publisherId=publisherId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->issueDelete: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Body parameters
Name Description
tuples
Query parameters
Name Description
query
String
Query string. Ignored when specific tuples provided.
publisher-id
String
An ID for this publisher (if AS_PUBLISH)

Responses

Status: 200 - Delete success

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query


issueQuery

Retreive streaming data

Server Sent Event (SSE)-formatted stream of continuous data. Closing this will end query. Must use EventClient or other SSE client.


/tables/{tablename}/tuples/{querytype}

Usage and SDK Samples

curl -X GET -H "Accept: text/event-stream" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples/{querytype}?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *querytype = querytype_example; // Type of query to run
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Retreive streaming data
[apiInstance issueQueryWith:tablename
    querytype:querytype
    query:query
    includeInternal:includeInternal
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var querytype = querytype_example; // {String} Type of query to run

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var querytype = querytype_example;  // String | Type of query to run
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Retreive streaming data
                Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.issueQuery: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$querytype = querytype_example; // String | Type of query to run
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

try {
    $result = $api_instance->issueQuery($tablename, $querytype, $query, $includeInternal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V10Api->issueQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V10Api;

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $querytype = querytype_example; # String | Type of query to run
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->issueQuery(tablename => $tablename, querytype => $querytype, query => $query, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->issueQuery: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
querytype = querytype_example # String | Type of query to run
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Retreive streaming data
    api_response = api_instance.issue_query(tablename, querytype, query=query, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->issueQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
querytype*
String
Type of query to run
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Continuous SSE stream

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query


issueSnapshotQuery

Retrieve data

Issue a snapshot query on the given table, with optional query.


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueSnapshotQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#issueSnapshotQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Retrieve data
[apiInstance issueSnapshotQueryWith:tablename
    query:query
    includeInternal:includeInternal
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Retrieve data
                Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.issueSnapshotQuery: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

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

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->issueSnapshotQuery(tablename => $tablename, query => $query, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->issueSnapshotQuery: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Retrieve data
    api_response = api_instance.issue_snapshot_query(tablename, query=query, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->issueSnapshotQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - JSON data, based on header

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query/Non-liveview table


publishToTable

Publish

Publish new list of tuples to a table


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?publisher-id="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The name of the target table
        PublishData tuples = ; // PublishData | The tuples to publish
        String publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired
        try {
            StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#publishToTable");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The name of the target table
        PublishData tuples = ; // PublishData | The tuples to publish
        String publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired
        try {
            StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#publishToTable");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The name of the target table
PublishData *tuples = ; // The tuples to publish
String *publisherId = publisherId_example; // An ID for this publisher; used to support server-side recovery features, if desired (optional)

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

// Publish
[apiInstance publishToTableWith:tablename
    tuples:tuples
    publisherId:publisherId
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The name of the target table

var tuples = ; // {PublishData} The tuples to publish

var opts = { 
  'publisherId': publisherId_example // {String} An ID for this publisher; used to support server-side recovery features, if desired
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The name of the target table
            var tuples = new PublishData(); // PublishData | The tuples to publish
            var publisherId = publisherId_example;  // String | An ID for this publisher; used to support server-side recovery features, if desired (optional) 

            try
            {
                // Publish
                StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.publishToTable: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The name of the target table
$tuples = ; // PublishData | The tuples to publish
$publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired

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

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The name of the target table
my $tuples = WWW::SwaggerClient::Object::PublishData->new(); # PublishData | The tuples to publish
my $publisherId = publisherId_example; # String | An ID for this publisher; used to support server-side recovery features, if desired

eval { 
    my $result = $api_instance->publishToTable(tablename => $tablename, tuples => $tuples, publisherId => $publisherId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V10Api->publishToTable: $@\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.V10Api()
tablename = tablename_example # String | The name of the target table
tuples =  # PublishData | The tuples to publish
publisherId = publisherId_example # String | An ID for this publisher; used to support server-side recovery features, if desired (optional)

try: 
    # Publish
    api_response = api_instance.publish_to_table(tablename, tuples, publisherId=publisherId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V10Api->publishToTable: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The name of the target table
Required
Body parameters
Name Description
tuples *
Query parameters
Name Description
publisher-id
String
An ID for this publisher; used to support server-side recovery features, if desired

Responses

Status: 200 - Published

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Not published


tryNonSnapshotQuery

Describe query

Tries to see if the query will parse, and if so, return the schema and parsed query


/tables/{tablename}/tuples/{querytype}

Usage and SDK Samples

curl -X HEAD -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples/{querytype}?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#tryNonSnapshotQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#tryNonSnapshotQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *querytype = querytype_example; // Type of query to run
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Describe query
[apiInstance tryNonSnapshotQueryWith:tablename
    querytype:querytype
    query:query
    includeInternal:includeInternal
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var querytype = querytype_example; // {String} Type of query to run

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var querytype = querytype_example;  // String | Type of query to run
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Describe query
                apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.tryNonSnapshotQuery: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$querytype = querytype_example; // String | Type of query to run
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

try {
    $api_instance->tryNonSnapshotQuery($tablename, $querytype, $query, $includeInternal);
} catch (Exception $e) {
    echo 'Exception when calling V10Api->tryNonSnapshotQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V10Api;

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $querytype = querytype_example; # String | Type of query to run
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    $api_instance->tryNonSnapshotQuery(tablename => $tablename, querytype => $querytype, query => $query, includeInternal => $includeInternal);
};
if ($@) {
    warn "Exception when calling V10Api->tryNonSnapshotQuery: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
querytype = querytype_example # String | Type of query to run
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Describe query
    api_instance.try_non_snapshot_query(tablename, querytype, query=query, includeInternal=includeInternal)
except ApiException as e:
    print("Exception when calling V10Api->tryNonSnapshotQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
querytype*
String
Type of query to run
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Query description details

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Invalid Query


tryQuery

Describe query

Tries to see if the query will parse, and if so, return the schema and parsed query


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X HEAD -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V10Api;

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

public class V10ApiExample {

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

        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        try {
            apiInstance.tryQuery(tablename, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#tryQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V10Api;

public class V10ApiExample {

    public static void main(String[] args) {
        V10Api apiInstance = new V10Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        try {
            apiInstance.tryQuery(tablename, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling V10Api#tryQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string (optional)

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

// Describe query
[apiInstance tryQueryWith:tablename
    query:query
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V10Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example // {String} Query string
};

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

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

            var apiInstance = new V10Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string (optional) 

            try
            {
                // Describe query
                apiInstance.tryQuery(tablename, query);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V10Api.tryQuery: " + 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\Api\V10Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string

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

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

my $api_instance = WWW::SwaggerClient::V10Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string

eval { 
    $api_instance->tryQuery(tablename => $tablename, query => $query);
};
if ($@) {
    warn "Exception when calling V10Api->tryQuery: $@\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.V10Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string (optional)

try: 
    # Describe query
    api_instance.try_query(tablename, query=query)
except ApiException as e:
    print("Exception when calling V10Api->tryQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
query
String
Query string

Responses

Status: 200 - Query description details

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Invalid Query


V11

createAlertRule

Alert create

Creates the alert.


/alerts

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        AlertRule alert = ; // AlertRule | The alert rule to create
        try {
            StatusType result = apiInstance.createAlertRule(alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#createAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        AlertRule alert = ; // AlertRule | The alert rule to create
        try {
            StatusType result = apiInstance.createAlertRule(alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#createAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

AlertRule *alert = ; // The alert rule to create

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

// Alert create
[apiInstance createAlertRuleWith:alert
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var alert = ; // {AlertRule} The alert rule to create


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

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

            var apiInstance = new V11Api();
            var alert = new AlertRule(); // AlertRule | The alert rule to create

            try
            {
                // Alert create
                StatusType result = apiInstance.createAlertRule(alert);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.createAlertRule: " + 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\Api\V11Api();
$alert = ; // AlertRule | The alert rule to create

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $alert = WWW::SwaggerClient::Object::AlertRule->new(); # AlertRule | The alert rule to create

eval { 
    my $result = $api_instance->createAlertRule(alert => $alert);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->createAlertRule: $@\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.V11Api()
alert =  # AlertRule | The alert rule to create

try: 
    # Alert create
    api_response = api_instance.create_alert_rule(alert)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->createAlertRule: %s\n" % e)

Parameters

Body parameters
Name Description
alert *

Responses

Status: 200 - Success status (message contains ID if sucessfull)

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Validation failed


deleteAlertRule

Alert delete

Deletes the alert rule.


/alerts/{alertid}

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts/{alertid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        try {
            StatusType result = apiInstance.deleteAlertRule(alertid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#deleteAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        try {
            StatusType result = apiInstance.deleteAlertRule(alertid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#deleteAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *alertid = alertid_example; // The alert rule's id

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

// Alert delete
[apiInstance deleteAlertRuleWith:alertid
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var alertid = alertid_example; // {String} The alert rule's id


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

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

            var apiInstance = new V11Api();
            var alertid = alertid_example;  // String | The alert rule's id

            try
            {
                // Alert delete
                StatusType result = apiInstance.deleteAlertRule(alertid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.deleteAlertRule: " + 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\Api\V11Api();
$alertid = alertid_example; // String | The alert rule's id

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $alertid = alertid_example; # String | The alert rule's id

eval { 
    my $result = $api_instance->deleteAlertRule(alertid => $alertid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->deleteAlertRule: $@\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.V11Api()
alertid = alertid_example # String | The alert rule's id

try: 
    # Alert delete
    api_response = api_instance.delete_alert_rule(alertid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->deleteAlertRule: %s\n" % e)

Parameters

Path parameters
Name Description
alertid*
String
The alert rule's id
Required

Responses

Status: 200 - Success status

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


getAlertRule

Get an Alert

Get specified alert rule


/alerts/{alertid}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts/{alertid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        try {
            AlertRule result = apiInstance.getAlertRule(alertid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        try {
            AlertRule result = apiInstance.getAlertRule(alertid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *alertid = alertid_example; // The alert rule's id

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

// Get an Alert
[apiInstance getAlertRuleWith:alertid
              completionHandler: ^(AlertRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var alertid = alertid_example; // {String} The alert rule's id


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

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

            var apiInstance = new V11Api();
            var alertid = alertid_example;  // String | The alert rule's id

            try
            {
                // Get an Alert
                AlertRule result = apiInstance.getAlertRule(alertid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.getAlertRule: " + 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\Api\V11Api();
$alertid = alertid_example; // String | The alert rule's id

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $alertid = alertid_example; # String | The alert rule's id

eval { 
    my $result = $api_instance->getAlertRule(alertid => $alertid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->getAlertRule: $@\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.V11Api()
alertid = alertid_example # String | The alert rule's id

try: 
    # Get an Alert
    api_response = api_instance.get_alert_rule(alertid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->getAlertRule: %s\n" % e)

Parameters

Path parameters
Name Description
alertid*
String
The alert rule's id
Required

Responses

Status: 200 - Alert rule details

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


getAlertRules

List all alerts

Gets all available alert rules from the server


/alerts

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

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

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        try {
            array[AlertRule] result = apiInstance.getAlertRules();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getAlertRules");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

// List all alerts
[apiInstance getAlertRulesWithCompletionHandler: 
              ^(array[AlertRule] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

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

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

            var apiInstance = new V11Api();

            try
            {
                // List all alerts
                array[AlertRule] result = apiInstance.getAlertRules();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.getAlertRules: " + 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\Api\V11Api();

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

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

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

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

try: 
    # List all alerts
    api_response = api_instance.get_alert_rules()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->getAlertRules: %s\n" % e)

Parameters

Responses

Status: 200 - List of all available alert rules

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


getTable

Gets the details of a specific table


/tables/{tablename}

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}?include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            TableInfo result = apiInstance.getTable(tablename, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getTable");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            TableInfo result = apiInstance.getTable(tablename, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getTable");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

[apiInstance getTableWith:tablename
    includeInternal:includeInternal
              completionHandler: ^(TableInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                TableInfo result = apiInstance.getTable(tablename, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.getTable: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$includeInternal = true; // Boolean | Should internal fields be included

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->getTable(tablename => $tablename, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->getTable: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    api_response = api_instance.get_table(tablename, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->getTable: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Table details

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name


getTables

Table List

Gets a list of all tables on the server


/tables

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables?with-permission=&with-type="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
        String withType = withType_example; // String | (v1.1+) Only return tables with the given type
        try {
            array['String'] result = apiInstance.getTables(withPermission, withType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getTables");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
        String withType = withType_example; // String | (v1.1+) Only return tables with the given type
        try {
            array['String'] result = apiInstance.getTables(withPermission, withType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getTables");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *withPermission = withPermission_example; // (v1.1+) Only return tables with the given allowedPermission (optional)
String *withType = withType_example; // (v1.1+) Only return tables with the given type (optional) (default to all)

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

// Table List
[apiInstance getTablesWith:withPermission
    withType:withType
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var opts = { 
  'withPermission': withPermission_example, // {String} (v1.1+) Only return tables with the given allowedPermission
  'withType': withType_example // {String} (v1.1+) Only return tables with the given type
};

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

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

            var apiInstance = new V11Api();
            var withPermission = withPermission_example;  // String | (v1.1+) Only return tables with the given allowedPermission (optional) 
            var withType = withType_example;  // String | (v1.1+) Only return tables with the given type (optional)  (default to all)

            try
            {
                // Table List
                array['String'] result = apiInstance.getTables(withPermission, withType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.getTables: " + 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\Api\V11Api();
$withPermission = withPermission_example; // String | (v1.1+) Only return tables with the given allowedPermission
$withType = withType_example; // String | (v1.1+) Only return tables with the given type

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $withPermission = withPermission_example; # String | (v1.1+) Only return tables with the given allowedPermission
my $withType = withType_example; # String | (v1.1+) Only return tables with the given type

eval { 
    my $result = $api_instance->getTables(withPermission => $withPermission, withType => $withType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->getTables: $@\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.V11Api()
withPermission = withPermission_example # String | (v1.1+) Only return tables with the given allowedPermission (optional)
withType = withType_example # String | (v1.1+) Only return tables with the given type (optional) (default to all)

try: 
    # Table List
    api_response = api_instance.get_tables(withPermission=withPermission, withType=withType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->getTables: %s\n" % e)

Parameters

Query parameters
Name Description
with-permission
String
(v1.1+) Only return tables with the given allowedPermission
with-type
String
(v1.1+) Only return tables with the given type

Responses

Status: 200 - Success

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


getVersion

Version info

Gets the version of the current server


/version

Usage and SDK Samples

curl -X GET "https://localhost/lv/api/v1/version"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

    public static void main(String[] args) {
        
        V11Api apiInstance = new V11Api();
        try {
            VersionInfo result = apiInstance.getVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#getVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

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

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

// Version info
[apiInstance getVersionWithCompletionHandler: 
              ^(VersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');

var api = new LiveViewRestApi.V11Api()

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {
            
            var apiInstance = new V11Api();

            try
            {
                // Version info
                VersionInfo result = apiInstance.getVersion();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.getVersion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try: 
    # Version info
    api_response = api_instance.get_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->getVersion: %s\n" % e)

Parameters

Responses

Status: 200 - Successful response


issueDelete

Delete rows

Delete specified tuples on the given table, with either a query or a list of tuple's key fields


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query=&publisher-id="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string. Ignored when specific tuples provided.
        PublishData tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
        String publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)
        try {
            StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string. Ignored when specific tuples provided.
        PublishData tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
        String publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)
        try {
            StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string. Ignored when specific tuples provided. (optional)
PublishData *tuples = ; // The tuples to delete (AS_PUBLISH; works with recovery) (optional)
String *publisherId = publisherId_example; // An ID for this publisher (if AS_PUBLISH) (optional)

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

// Delete rows
[apiInstance issueDeleteWith:tablename
    query:query
    tuples:tuples
    publisherId:publisherId
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example, // {String} Query string. Ignored when specific tuples provided.
  'tuples': , // {PublishData} The tuples to delete (AS_PUBLISH; works with recovery)
  'publisherId': publisherId_example // {String} An ID for this publisher (if AS_PUBLISH)
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string. Ignored when specific tuples provided. (optional) 
            var tuples = new PublishData(); // PublishData | The tuples to delete (AS_PUBLISH; works with recovery) (optional) 
            var publisherId = publisherId_example;  // String | An ID for this publisher (if AS_PUBLISH) (optional) 

            try
            {
                // Delete rows
                StatusType result = apiInstance.issueDelete(tablename, query, tuples, publisherId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.issueDelete: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string. Ignored when specific tuples provided.
$tuples = ; // PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
$publisherId = publisherId_example; // String | An ID for this publisher (if AS_PUBLISH)

try {
    $result = $api_instance->issueDelete($tablename, $query, $tuples, $publisherId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V11Api->issueDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V11Api;

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string. Ignored when specific tuples provided.
my $tuples = WWW::SwaggerClient::Object::PublishData->new(); # PublishData | The tuples to delete (AS_PUBLISH; works with recovery)
my $publisherId = publisherId_example; # String | An ID for this publisher (if AS_PUBLISH)

eval { 
    my $result = $api_instance->issueDelete(tablename => $tablename, query => $query, tuples => $tuples, publisherId => $publisherId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->issueDelete: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string. Ignored when specific tuples provided. (optional)
tuples =  # PublishData | The tuples to delete (AS_PUBLISH; works with recovery) (optional)
publisherId = publisherId_example # String | An ID for this publisher (if AS_PUBLISH) (optional)

try: 
    # Delete rows
    api_response = api_instance.issue_delete(tablename, query=query, tuples=tuples, publisherId=publisherId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->issueDelete: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Body parameters
Name Description
tuples
Query parameters
Name Description
query
String
Query string. Ignored when specific tuples provided.
publisher-id
String
An ID for this publisher (if AS_PUBLISH)

Responses

Status: 200 - Delete success

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query


issueQuery

Retreive streaming data

Server Sent Event (SSE)-formatted stream of continuous data. Closing this will end query. Must use EventClient or other SSE client.


/tables/{tablename}/tuples/{querytype}

Usage and SDK Samples

curl -X GET -H "Accept: text/event-stream" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples/{querytype}?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *querytype = querytype_example; // Type of query to run
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Retreive streaming data
[apiInstance issueQueryWith:tablename
    querytype:querytype
    query:query
    includeInternal:includeInternal
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var querytype = querytype_example; // {String} Type of query to run

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var querytype = querytype_example;  // String | Type of query to run
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Retreive streaming data
                Data result = apiInstance.issueQuery(tablename, querytype, query, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.issueQuery: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$querytype = querytype_example; // String | Type of query to run
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

try {
    $result = $api_instance->issueQuery($tablename, $querytype, $query, $includeInternal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V11Api->issueQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V11Api;

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $querytype = querytype_example; # String | Type of query to run
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->issueQuery(tablename => $tablename, querytype => $querytype, query => $query, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->issueQuery: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
querytype = querytype_example # String | Type of query to run
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Retreive streaming data
    api_response = api_instance.issue_query(tablename, querytype, query=query, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->issueQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
querytype*
String
Type of query to run
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Continuous SSE stream

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query


issueSnapshotQuery

Retrieve data

Issue a snapshot query on the given table, with optional query.


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueSnapshotQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#issueSnapshotQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Retrieve data
[apiInstance issueSnapshotQueryWith:tablename
    query:query
    includeInternal:includeInternal
              completionHandler: ^(Data output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Retrieve data
                Data result = apiInstance.issueSnapshotQuery(tablename, query, includeInternal);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.issueSnapshotQuery: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    my $result = $api_instance->issueSnapshotQuery(tablename => $tablename, query => $query, includeInternal => $includeInternal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->issueSnapshotQuery: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Retrieve data
    api_response = api_instance.issue_snapshot_query(tablename, query=query, includeInternal=includeInternal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->issueSnapshotQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - JSON data, based on header

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Invalid Query/Non-liveview table


publishToTable

Publish

Publish new list of tuples to a table


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?publisher-id="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The name of the target table
        PublishData tuples = ; // PublishData | The tuples to publish
        String publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired
        try {
            StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#publishToTable");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The name of the target table
        PublishData tuples = ; // PublishData | The tuples to publish
        String publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired
        try {
            StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#publishToTable");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The name of the target table
PublishData *tuples = ; // The tuples to publish
String *publisherId = publisherId_example; // An ID for this publisher; used to support server-side recovery features, if desired (optional)

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

// Publish
[apiInstance publishToTableWith:tablename
    tuples:tuples
    publisherId:publisherId
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The name of the target table

var tuples = ; // {PublishData} The tuples to publish

var opts = { 
  'publisherId': publisherId_example // {String} An ID for this publisher; used to support server-side recovery features, if desired
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The name of the target table
            var tuples = new PublishData(); // PublishData | The tuples to publish
            var publisherId = publisherId_example;  // String | An ID for this publisher; used to support server-side recovery features, if desired (optional) 

            try
            {
                // Publish
                StatusType result = apiInstance.publishToTable(tablename, tuples, publisherId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.publishToTable: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The name of the target table
$tuples = ; // PublishData | The tuples to publish
$publisherId = publisherId_example; // String | An ID for this publisher; used to support server-side recovery features, if desired

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The name of the target table
my $tuples = WWW::SwaggerClient::Object::PublishData->new(); # PublishData | The tuples to publish
my $publisherId = publisherId_example; # String | An ID for this publisher; used to support server-side recovery features, if desired

eval { 
    my $result = $api_instance->publishToTable(tablename => $tablename, tuples => $tuples, publisherId => $publisherId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->publishToTable: $@\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.V11Api()
tablename = tablename_example # String | The name of the target table
tuples =  # PublishData | The tuples to publish
publisherId = publisherId_example # String | An ID for this publisher; used to support server-side recovery features, if desired (optional)

try: 
    # Publish
    api_response = api_instance.publish_to_table(tablename, tuples, publisherId=publisherId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->publishToTable: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The name of the target table
Required
Body parameters
Name Description
tuples *
Query parameters
Name Description
publisher-id
String
An ID for this publisher; used to support server-side recovery features, if desired

Responses

Status: 200 - Published

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 404 - Invalid table name

Status: 422 - Not published


tryNonSnapshotQuery

Describe query

Tries to see if the query will parse, and if so, return the schema and parsed query


/tables/{tablename}/tuples/{querytype}

Usage and SDK Samples

curl -X HEAD -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples/{querytype}?query=&include-internal="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#tryNonSnapshotQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String querytype = querytype_example; // String | Type of query to run
        String query = query_example; // String | Query string
        Boolean includeInternal = true; // Boolean | Should internal fields be included
        try {
            apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#tryNonSnapshotQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *querytype = querytype_example; // Type of query to run
String *query = query_example; // Query string (optional)
Boolean *includeInternal = true; // Should internal fields be included (optional) (default to false)

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

// Describe query
[apiInstance tryNonSnapshotQueryWith:tablename
    querytype:querytype
    query:query
    includeInternal:includeInternal
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var querytype = querytype_example; // {String} Type of query to run

var opts = { 
  'query': query_example, // {String} Query string
  'includeInternal': true // {Boolean} Should internal fields be included
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var querytype = querytype_example;  // String | Type of query to run
            var query = query_example;  // String | Query string (optional) 
            var includeInternal = true;  // Boolean | Should internal fields be included (optional)  (default to false)

            try
            {
                // Describe query
                apiInstance.tryNonSnapshotQuery(tablename, querytype, query, includeInternal);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.tryNonSnapshotQuery: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$querytype = querytype_example; // String | Type of query to run
$query = query_example; // String | Query string
$includeInternal = true; // Boolean | Should internal fields be included

try {
    $api_instance->tryNonSnapshotQuery($tablename, $querytype, $query, $includeInternal);
} catch (Exception $e) {
    echo 'Exception when calling V11Api->tryNonSnapshotQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::V11Api;

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $querytype = querytype_example; # String | Type of query to run
my $query = query_example; # String | Query string
my $includeInternal = true; # Boolean | Should internal fields be included

eval { 
    $api_instance->tryNonSnapshotQuery(tablename => $tablename, querytype => $querytype, query => $query, includeInternal => $includeInternal);
};
if ($@) {
    warn "Exception when calling V11Api->tryNonSnapshotQuery: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
querytype = querytype_example # String | Type of query to run
query = query_example # String | Query string (optional)
includeInternal = true # Boolean | Should internal fields be included (optional) (default to false)

try: 
    # Describe query
    api_instance.try_non_snapshot_query(tablename, querytype, query=query, includeInternal=includeInternal)
except ApiException as e:
    print("Exception when calling V11Api->tryNonSnapshotQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
querytype*
String
Type of query to run
Required
Query parameters
Name Description
query
String
Query string
include-internal
Boolean
Should internal fields be included

Responses

Status: 200 - Query description details

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Invalid Query


tryQuery

Describe query

Tries to see if the query will parse, and if so, return the schema and parsed query


/tables/{tablename}/tuples

Usage and SDK Samples

curl -X HEAD -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/tables/{tablename}/tuples?query="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        try {
            apiInstance.tryQuery(tablename, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#tryQuery");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String tablename = tablename_example; // String | The table name to query
        String query = query_example; // String | Query string
        try {
            apiInstance.tryQuery(tablename, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#tryQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *tablename = tablename_example; // The table name to query
String *query = query_example; // Query string (optional)

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

// Describe query
[apiInstance tryQueryWith:tablename
    query:query
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var tablename = tablename_example; // {String} The table name to query

var opts = { 
  'query': query_example // {String} Query string
};

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

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

            var apiInstance = new V11Api();
            var tablename = tablename_example;  // String | The table name to query
            var query = query_example;  // String | Query string (optional) 

            try
            {
                // Describe query
                apiInstance.tryQuery(tablename, query);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.tryQuery: " + 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\Api\V11Api();
$tablename = tablename_example; // String | The table name to query
$query = query_example; // String | Query string

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $tablename = tablename_example; # String | The table name to query
my $query = query_example; # String | Query string

eval { 
    $api_instance->tryQuery(tablename => $tablename, query => $query);
};
if ($@) {
    warn "Exception when calling V11Api->tryQuery: $@\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.V11Api()
tablename = tablename_example # String | The table name to query
query = query_example # String | Query string (optional)

try: 
    # Describe query
    api_instance.try_query(tablename, query=query)
except ApiException as e:
    print("Exception when calling V11Api->tryQuery: %s\n" % e)

Parameters

Path parameters
Name Description
tablename*
String
The table name to query
Required
Query parameters
Name Description
query
String
Query string

Responses

Status: 200 - Query description details

Name Type Format Description
X-Query-Schema String Schema of the query result
X-Query-Keys String Key field or key fields, comma seperated
X-Query-Components String The parsed query components

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Invalid Query


updateAlertRule

Alert update

Updates the alert rule. Only changed fields are needed


/alerts/{alertid}

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts/{alertid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        AlertRule alert = ; // AlertRule | The alert rule to update
        try {
            StatusType result = apiInstance.updateAlertRule(alertid, alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#updateAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        String alertid = alertid_example; // String | The alert rule's id
        AlertRule alert = ; // AlertRule | The alert rule to update
        try {
            StatusType result = apiInstance.updateAlertRule(alertid, alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#updateAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *alertid = alertid_example; // The alert rule's id
AlertRule *alert = ; // The alert rule to update

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

// Alert update
[apiInstance updateAlertRuleWith:alertid
    alert:alert
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var alertid = alertid_example; // {String} The alert rule's id

var alert = ; // {AlertRule} The alert rule to update


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

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

            var apiInstance = new V11Api();
            var alertid = alertid_example;  // String | The alert rule's id
            var alert = new AlertRule(); // AlertRule | The alert rule to update

            try
            {
                // Alert update
                StatusType result = apiInstance.updateAlertRule(alertid, alert);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.updateAlertRule: " + 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\Api\V11Api();
$alertid = alertid_example; // String | The alert rule's id
$alert = ; // AlertRule | The alert rule to update

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $alertid = alertid_example; # String | The alert rule's id
my $alert = WWW::SwaggerClient::Object::AlertRule->new(); # AlertRule | The alert rule to update

eval { 
    my $result = $api_instance->updateAlertRule(alertid => $alertid, alert => $alert);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->updateAlertRule: $@\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.V11Api()
alertid = alertid_example # String | The alert rule's id
alert =  # AlertRule | The alert rule to update

try: 
    # Alert update
    api_response = api_instance.update_alert_rule(alertid, alert)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->updateAlertRule: %s\n" % e)

Parameters

Path parameters
Name Description
alertid*
String
The alert rule's id
Required
Body parameters
Name Description
alert *

Responses

Status: 200 - Success status

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions

Status: 422 - Validation failed


validateAlertRule

Alert validate

Validate the alert rule.


/alerts/validator

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://localhost/lv/api/v1/alerts/validator"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.V11Api;

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

public class V11ApiExample {

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

        V11Api apiInstance = new V11Api();
        AlertRule alert = ; // AlertRule | The alert rule to validate
        try {
            StatusType result = apiInstance.validateAlertRule(alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#validateAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.V11Api;

public class V11ApiExample {

    public static void main(String[] args) {
        V11Api apiInstance = new V11Api();
        AlertRule alert = ; // AlertRule | The alert rule to validate
        try {
            StatusType result = apiInstance.validateAlertRule(alert);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V11Api#validateAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

AlertRule *alert = ; // The alert rule to validate

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

// Alert validate
[apiInstance validateAlertRuleWith:alert
              completionHandler: ^(StatusType output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LiveViewRestApi = require('live_view_rest_api');
var defaultClient = LiveViewRestApi.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new LiveViewRestApi.V11Api()

var alert = ; // {AlertRule} The alert rule to validate


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

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

            var apiInstance = new V11Api();
            var alert = new AlertRule(); // AlertRule | The alert rule to validate

            try
            {
                // Alert validate
                StatusType result = apiInstance.validateAlertRule(alert);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling V11Api.validateAlertRule: " + 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\Api\V11Api();
$alert = ; // AlertRule | The alert rule to validate

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

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

my $api_instance = WWW::SwaggerClient::V11Api->new();
my $alert = WWW::SwaggerClient::Object::AlertRule->new(); # AlertRule | The alert rule to validate

eval { 
    my $result = $api_instance->validateAlertRule(alert => $alert);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V11Api->validateAlertRule: $@\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.V11Api()
alert =  # AlertRule | The alert rule to validate

try: 
    # Alert validate
    api_response = api_instance.validate_alert_rule(alert)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V11Api->validateAlertRule: %s\n" % e)

Parameters

Body parameters
Name Description
alert *

Responses

Status: 200 - Validation status

Status: 401 - Missing authentication

Status: 403 - User doesn't have required permissions


Generated 2018-01-15T13:02:20.127-05:00