RESTful API v2.1 r15 (latest)

curl \
    -H "Accept: application/json" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
    -X POST \
    "https://your.statseeker.server/api/v2.1/group/?indent=3" \
    -d '{"data":[{"name":"Group1"}]}' 

curl \
    -H "Accept: application/json" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
    -X POST \
    "https://your.statseeker.server/api/v2.1/group/?indent=3" \
    -d "{\"data\":[{\"name\":\"Group1\"}]}" 

curl \
	-D -X POST \
	-H "Content-type: application/x-www-form-urlencoded" \
	-d "user=user_name&password=user_password" \
	"https://your.statseeker.server/ss-auth"

Subsequent request to access the API.

curl \ 
	-X GET
	-H "Accept: application/json" \ 
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	"https://your.statseeker.server/api/v2.1"

# import requests for handling connection and encoding
import requests
import json

def do_request(server, query, user, pword):

    # request auth token
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
	
	# If auth was successful, include my token and make my API request
    if resp.status_code == 200:        
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'your_api_user'
pword = 'your_user_password'
# API root endpoint
query = 'api/v2.1'
# optional response formatting
query += '/?indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)

# output the response to my API request
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
   
        # Include my token and make my API request
        headers["content_type"] = :json
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
end
# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'your_api_user'
pword = 'your_user_password'
# api root endpoint
$query = 'api/v2.1'
# optional formatting of the response
$query += '/?links=none&indent=3'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# optional response formatting
query += '/?indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers["content_type"] = :json
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# optional formatting of the response
$query += '/?links=none&indent=3'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

curl \ 
	-H "Accept: application/json" \ 
	-H "Content-Type: application/json" \
	-u user:pword \
	"https://your.statseeker.server/api/v2.1"

 

# import requests for handling connection and encoding
import requests, json

# specify the api endpoint to be used
url = "https://your.statseeker.server/api/v2.1/"

# credentials
user = "username"
pword = "password"

# headers
headers = {"Accept":"application/json", "Content-Type":"application/json"}

# send request 
r = requests.get(url, headers=headers, auth=(user, pword))
print(r.status_code)
print(r.json())

# install with: $ gem install rest-client
require 'rest_client'

# api root endpoint
$uri = 'https:/your.statseeker.server/api/v2.1/'

# api user credentials
$user = 'username'
$pword = 'password'

# optional formatting of the response for onscreen readability
$rspFormat = '?&indent=3'

# send request
response = RestClient::Request.new({
      method: :get,
      url: $uri + $rspFormat,
      user: $user,
      password: $pword,
    }).execute
	
# output response to screen
puts "#{response.to_str}"

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server/api/v2.1/cdt_device/?fields=name,id,community,ipaddress,snmp_version&groups=<GROUP NAME>&indent=3"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/cdt_device'
# specify fields to be returned
query += '/?fields=name,id,community,ipaddress,snmp_version'
# Filters
query += '&groups=<GROUP NAME>'
# optional response formatting
query += '&indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += "/cdt_device"
# specify fields to be returned
$query += '?fields=name,id,community,ipaddress,snmp_version'
# Filters
$query += '&groups=<GROUP NAME>'
# optional response formatting
$query += '&indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
  "info": "The Statseeker RESTful API",
  "data": {
    "objects": [
      {
        "status": {
          "errcode": 0,
          "success": true
        },
        "data": [
          {
            "snmp_version": 2,
            "ipaddress": "10.116.4.172",
            "name": "Brisbane-Server1",
            "community": "public",
            "id": 551
          },
          {
            "snmp_version": 2,
            "ipaddress": "10.116.4.180",
            "name": "Brisbane-Server2",
            "community": "public",
            "id": 552
          },
          {
            "snmp_version": 2,
            "ipaddress": "10.116.4.186",
            "name": "Sydney-Server1",
            "community": "public",
            "id": 555
          },
          {
            "snmp_version": 2,
            "ipaddress": "10.116.4.187",
            "name": "Sydney-Server2",
            "community": "public",
            "id": 556
          },
          {
            "snmp_version": 2,
            "ipaddress": "10.116.4.194",
            "name": "Melbourne-Server1",
            "community": "public",
            "id": 557
          }
        ],
        "type": "cdt_device",
        "data_total": 5
      }
    ],
    "errmsg": "ok",
    "success": true,
    "time": 1496188135
  },
  "links": [],
  "api_version": "2.1"
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X POST \
	"https://your.statseeker.server/api/v2.1/group/?indent=3" \
	-d '{"data":[{"name":"<GROUP NAME 1>"},{"name":"<GROUP NAME 2>"}]}' 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.post(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.post(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/group'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"data":[{"name":"<GROUP NAME 1>"},{"name":"<GROUP NAME 2>"}]})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :post,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :post,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/group'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"data":[{"name":"<GROUP NAME 1>"},{"name":"<GROUP NAME 2>"}]}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
  "info": "The Statseeker RESTful API",
  "data": {
    "objects": [
      {
        "status": {
          "errcode": 0,
          "success": true
        },
        "data": [
          {
            "name": "<GROUP NAME 1>",
            "id": 46458
          },
          {
            "name": "<GROUP NAME 2>",
            "id": 46459
          }
        ],
        "type": "group",
        "data_total": 2
      }
    ],
    "errmsg": "ok",
    "success": true,
    "time": 1496190459
  },
  "api_version": "2.1"
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X PUT \
	"https://your.statseeker.server/api/v2.1/group/?indent=3" \
	-d '{"fields":{"name":{"field":"name","filter":{"query":"=\u0027<OLD GROUP NAME>\u0027"}}},"data":[{"name":"<NEW GROUP NAME>"}]}'

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.put(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.put(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += ''
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"fields":{"name":{"field":"name","filter":{"query":"='<OLD GROUP NAME>'"}}},"data":[{"name":"<NEW GROUP NAME>"}]})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :put,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :put,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/group'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"fields":{"name":{"field":"name","filter":{"query":"=\'<OLD GROUP NAME>\'"}}},"data":[{"name":"<NEW GROUP NAME>"}]}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
  "info": "The Statseeker RESTful API",
  "data": {
    "errmsg": "ok",
    "success": true,
    "time": 1496190511
  },
  "api_version": "2.1"
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X DELETE \
	"https://your.statseeker.server/api/v2.1/group/?indent=3" \ 
	-d '{"fields":{"name":{"field":"name","filter":{"query":"LIKE \u0027<FILTER STRING>\u0027"}}}}'

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.delete(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.delete(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/group'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"fields":{"name":{"field":"name","filter":{"query":"LIKE '<FILTER STRING>'"}}}})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :delete,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :delete,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/group'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"fields":{"name":{"field":"name","filter":{"query":"LIKE \'<FILTER STRING>\'"}}}}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623638287
   }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server1/api/v2.1/user/describe/?indent=3"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += 'user/describe'
# optional response formatting
query += '/?indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}') 

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += 'user/describe'
# optional response formatting
$query += '/?indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
{
    "version": "2.1",
    "revision": "13",
    "info": "The Statseeker RESTful API",
    "data": {
        "success": true,
        "errmsg": "ok",
        "time": 1646798321,
        "objects": [
            {
                "title": "User",
                "type": "user",
                "description": "Statseeker Users",
                "commands": {
                    "describe": {
                        "valid_fields": null,
                        "valid_data": null
                    },
                    "add": {
                        "valid_data": {
                            "name": {
                                "required": true
                            },
                            "tz": {
                                "required": false
                            },
                            "top_n": {
                                "required": false
                            },
                            "email": {
                                "required": false
                            },
                            "reportRowSpacing": {
                                "required": false
                            },
                            "exportDateFormat": {
                                "required": false
                            },
                            "auth_ttl": {
                                "required": false
                            },
                            "api": {
                                "required": false
                            },
                            "auth": {
                                "required": false
                            },
                            "auth_refresh": {
                                "required": false
                            },
                            "password": {
                                "required": false
                            },
                            "is_admin": {
                                "required": false
                            }
                        },
                        "valid_fields": null
                    },
                    "update": {
                        "valid_fields": {
                            "auth": {
                                "required": false
                            },
                            "auth_refresh": {
                                "required": false
                            },
                            "id": {
                                "required": false
                            },
                            "is_admin": {
                                "required": false
                            },
                            "password": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "tz": {
                                "required": false
                            },
                            "top_n": {
                                "required": false
                            },
                            "email": {
                                "required": false
                            },
                            "reportRowSpacing": {
                                "required": false
                            },
                            "api": {
                                "required": false
                            },
                            "auth_ttl": {
                                "required": false
                            },
                            "exportDateFormat": {
                                "required": false
                            }
                        },
                        "valid_data": {
                            "reportRowSpacing": {
                                "required": false
                            },
                            "api": {
                                "required": false
                            },
                            "exportDateFormat": {
                                "required": false
                            },
                            "auth_ttl": {
                                "required": false
                            },
                            "tz": {
                                "required": false
                            },
                            "top_n": {
                                "required": false
                            },
                            "email": {
                                "required": false
                            },
                            "is_admin": {
                                "required": false
                            },
                            "password": {
                                "required": false
                            },
                            "auth_refresh": {
                                "required": false
                            },
                            "auth": {
                                "required": false
                            }
                        }
                    },
                    "get": {
                        "valid_fields": {
                            "email": {
                                "required": false
                            },
                            "tz": {
                                "required": false
                            },
                            "top_n": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "api": {
                                "required": false
                            },
                            "auth_ttl": {
                                "required": false
                            },
                            "exportDateFormat": {
                                "required": false
                            },
                            "reportRowSpacing": {
                                "required": false
                            },
                            "auth_refresh": {
                                "required": false
                            },
                            "auth": {
                                "required": false
                            },
                            "is_admin": {
                                "required": false
                            },
                            "password": {
                                "required": false
                            },
                            "id": {
                                "required": false
                            }
                        },
                        "valid_data": null
                    },
                    "delete": {
                        "valid_fields": {
                            "email": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "tz": {
                                "required": false
                            },
                            "top_n": {
                                "required": false
                            },
                            "exportDateFormat": {
                                "required": false
                            },
                            "auth_ttl": {
                                "required": false
                            },
                            "api": {
                                "required": false
                            },
                            "reportRowSpacing": {
                                "required": false
                            },
                            "auth": {
                                "required": false
                            },
                            "auth_refresh": {
                                "required": false
                            },
                            "id": {
                                "required": false
                            },
                            "password": {
                                "required": false
                            },
                            "is_admin": {
                                "required": false
                            }
                        },
                        "valid_data": null
                    }
                },
                "fields": {
                    "email": {
                        "title": "Email",
                        "description": "User email address",
                        "datatype": "string"
                    },
                    "name": {
                        "description": "User name",
                        "datatype": "string",
                        "title": "Name"
                    },
                    "tz": {
                        "description": "User time zone",
                        "datatype": "string",
                        "title": "Time Zone"
                    },
                    "top_n": {
                        "description": "The default Top N number for the user",
                        "datatype": "integer",
                        "title": "Top N"
                    },
                    "exportDateFormat": {
                        "description": "User specified Date Format",
                        "datatype": "string",
                        "title": "Date Format"
                    },
                    "auth_ttl": {
                        "description": "The TTL for authentication tokens (in seconds)",
                        "datatype": "integer",
                        "title": "Authentication TTL"
                    },
                    "api": {
                        "description": "User API access permission",
                        "datatype": "string",
                        "title": "API Access"
                    },
                    "reportRowSpacing": {
                        "datatype": "string",
                        "description": "The report row spacing preference for the user",
                        "title": "Report Row Spacing"
                    },
                    "auth": {
                        "datatype": "string",
                        "description": "User authentication method",
                        "title": "Authentication method"
                    },
                    "auth_refresh": {
                        "description": "The time allowed after a token has expired that it will be refreshed (in seconds)",
                        "datatype": "integer",
                        "title": "Authentication Refresh"
                    },
                    "id": {
                        "title": "ID",
                        "description": "User Identifier",
                        "datatype": "integer"
                    },
                    "password": {
                        "title": "Password",
                        "description": "User password",
                        "datatype": "string"
                    },
                    "is_admin": {
                        "title": "Is Admin",
                        "datatype": "integer",
                        "description": "Whether the user has admin access"
                    }
                },
                "info": {
                    "allow_grouping": 1
                },
                "allow_formula_fields": true,
                "links": {},
                "global_field_options": {
                    "aggregation_format": {
                        "description": "Aggregation formats to apply when group_by option is provided",
                        "values": {
                            "first": {
                                "title": "First",
                                "description": "First value in the group (default)"
                            },
                            "last": {
                                "title": "Last",
                                "description": "Last value in the group"
                            },
                            "avg": {
                                "title": "Average",
                                "description": "Average of the values in the group"
                            },
                            "count": {
                                "title": "Count",
                                "description": "Number on non-null values in the group"
                            },
                            "count_all": {
                                "title": "Count (include NULL)",
                                "description": "Number of values in the group (including null values)"
                            },
                            "count_unique": {
                                "title": "Unique count",
                                "description": "Number of unique non-null values in the group"
                            },
                            "count_unique_all": {
                                "title": "Unique count (include NULL)",
                                "description": "Number of unique values in the group (including null values)"
                            },
                            "cat": {
                                "title": "Concatenate",
                                "description": "Concatenation of the values in the group"
                            },
                            "list": {
                                "title": "List",
                                "description": "Comma separated concatenation of the values in the group"
                            },
                            "list_unique": {
                                "title": "Unique List",
                                "description": "Comma separated concatenation of the unique values in the group"
                            },
                            "min": {
                                "title": "Minimum",
                                "description": "Minimum of the values in the group"
                            },
                            "max": {
                                "title": "Maximum",
                                "description": "Maximum of the values in the group"
                            },
                            "sum": {
                                "title": "Sum",
                                "description": "Sum of all values in the group (null if no valid values)"
                            },
                            "total": {
                                "title": "Total",
                                "description": "Sum of all values in the group (0 if no valid values)"
                            },
                            "median": {
                                "title": "Median",
                                "description": "Median of the values in the group"
                            },
                            "95th": {
                                "title": "95th percentile",
                                "description": "95th percentile of the values in the group"
                            },
                            "stddev": {
                                "title": "Standard deviation",
                                "description": "Standard deviation of the values in the group"
                            }
                        }
                    }
                }
            }
        ]
    },
    "links": [
        {
            "link": "/api/v2.1/user/describe",
            "rel": "self"
        },
        {
            "link": "/api/v2.1",
            "rel": "base"
        },
        {
            "link": "/api/v2.1/user",
            "rel": "collection"
        }
    ]
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server1/api/v2.1/cdt_device/describe/?indent=3"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += 'cdt_device/describe'
# optional response formatting
query += '/?indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}') 

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += 'cdt_device/describe'
# optional response formatting
$query += '/?indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
{
    "version": "2.1",
    "revision": "13",
    "info": "The Statseeker RESTful API",
    "data": {
        "success": true,
        "errmsg": "ok",
        "time": 1646798484,
        "objects": [
            {
                "type": "cdt_device",
                "title": "Device",
                "description": "The custom data entities for the device table",
                "fields": {
                    "id": {
                        "title": "ID",
                        "description": "The entity identifier",
                        "datatype": "integer"
                    },
                    "name": {
                        "title": "Name",
                        "description": "The entity name",
                        "datatype": "string"
                    },
                    "deviceid": {
                        "title": "Device ID",
                        "description": "The ID of the parent device",
                        "datatype": "integer"
                    },
                    "idx": {
                        "title": "Index",
                        "description": "The base SNMP index for this entity",
                        "datatype": "string"
                    },
                    "table": {
                        "title": "Table",
                        "description": "The table to which the entity belongs",
                        "datatype": "string"
                    },
                    "poll": {
                        "title": "Poll State",
                        "description": "The poll state of the entity",
                        "datatype": "string"
                    },
                    "auth_method": {
                        "title": "SNMPv3 Authentication Method",
                        "description": "Authentication method for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "auth_pass": {
                        "title": "SNMPv3 Authentication Password",
                        "description": "Authentication password for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "auth_user": {
                        "title": "SNMPv3 Authentication Username",
                        "description": "Authentication user for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "community": {
                        "title": "Community",
                        "description": "The community string status of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "context": {
                        "title": "SNMPv3 Context",
                        "description": "Context for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "custom_data_details": {
                        "title": "Custom Data Details",
                        "description": "A JSON string object indicating which custom entities have been found during a discovery",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "discover_getNext": {
                        "title": "Use GetNext",
                        "description": "Walk this device using SNMP getNext instead of getBulk",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "discover_minimal": {
                        "title": "Use Minimal Walk",
                        "description": "Walk this device using a minimal set of oids",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "discover_snmpv1": {
                        "title": "Use SNMPv1",
                        "description": "Walk this device using SNMPv1",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "hostname": {
                        "title": "Hostname",
                        "description": "The hostname of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "ipaddress": {
                        "title": "IP Address",
                        "description": "The IP address of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "description": "The user defined latitude of the device's location",
                        "polltype": "cfg",
                        "datatype": "float"
                    },
                    "longitude": {
                        "title": "Longitude",
                        "description": "The user defined longitude of the device's location",
                        "polltype": "cfg",
                        "datatype": "float"
                    },
                    "manual_name": {
                        "title": "User Defined Name",
                        "description": "The user defined name of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "memorySize": {
                        "title": "Memory Size",
                        "description": "The amount of physical read-write memory contained by the entity",
                        "polltype": "cfg",
                        "units": "bytes",
                        "symbol": "B",
                        "datatype": "integer"
                    },
                    "mis": {
                        "title": "MAC/IP/Switch Collection State",
                        "description": "Include this device in the MIS report calculations",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "ping_dup": {
                        "title": "Ping Duplicate",
                        "description": "Number of duplicate ping responses received",
                        "polltype": "tsc",
                        "interval": 3600,
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative",
                                                "description": "whether to use cumulative forecasts",
                                                "default": false
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "title": "Is Cumulative",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "description": "whether to use cumulative trendline"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_lost1": {
                        "title": "Ping Lost 1",
                        "description": "Number of times that a single ping request is lost",
                        "polltype": "tsc",
                        "interval": 3600,
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative",
                                                "description": "whether to use cumulative forecasts",
                                                "default": false
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "title": "Is Cumulative",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "description": "whether to use cumulative trendline"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_lost2": {
                        "title": "Ping Lost 2",
                        "description": "Number of times that two ping requests in a row have been lost",
                        "polltype": "tsc",
                        "interval": 3600,
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative",
                                                "description": "whether to use cumulative forecasts",
                                                "default": false
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "title": "Is Cumulative",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "description": "whether to use cumulative trendline"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_lost3": {
                        "title": "Ping Lost 3",
                        "description": "Number of times that three ping requests in a row have been lost",
                        "polltype": "tsc",
                        "interval": 3600,
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative",
                                                "description": "whether to use cumulative forecasts",
                                                "default": false
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "title": "Is Cumulative",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "description": "whether to use cumulative trendline"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_lost4": {
                        "title": "Ping Lost 4",
                        "description": "Number of times that four ping requests in a row have been lost",
                        "polltype": "tsc",
                        "interval": 3600,
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative",
                                                "description": "whether to use cumulative forecasts",
                                                "default": false
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "title": "Is Cumulative",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "description": "whether to use cumulative trendline"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_outage": {
                        "title": "Ping Outage",
                        "description": "Number of seconds to wait before a device is considered to be down",
                        "polltype": "cfg",
                        "datatype": "integer"
                    },
                    "ping_poll": {
                        "title": "Ping Poll",
                        "description": "The ping polling status of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "ping_rtt": {
                        "title": "Ping RTT",
                        "description": "The current ping state of the device",
                        "polltype": "tsg",
                        "interval": 60,
                        "units": "milliseconds",
                        "symbol": "ms",
                        "scale": "time",
                        "datatype": "integer",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Whether to return the sum of forecast values",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative"
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "description": "Whether to fit a trendline to the sum of the data values",
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_rtt_ms": {
                        "title": "Ping RTT(High Precision)",
                        "description": "The current ping state of the device in ms to 3 decimal places",
                        "polltype": "tsg",
                        "interval": 60,
                        "units": "milliseconds",
                        "symbol": "ms",
                        "scale": "time",
                        "datatype": "float",
                        "options": {
                            "value_time": {
                                "description": "The timestamp for a timeseries event",
                                "values": {
                                    "none": "Do not return a timestamp",
                                    "mid": "The midpoint of the start and end timestamps",
                                    "end": "The timestamp at which the event finished",
                                    "start": "The timestamp at which the event began",
                                    "all": "An array of start, mid and end"
                                }
                            },
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "median": {
                                        "description": "Median of the data",
                                        "title": "Median"
                                    },
                                    "trendline_daily_change": {
                                        "title": "Trendline daily change",
                                        "description": "Slope of the trendline (units/day)"
                                    },
                                    "anomaly_metric": {
                                        "description": "Metric from -100 to 100 indicating whether requested timeseries values are unusually large or small",
                                        "title": "Anomaly metric"
                                    },
                                    "trendline_upr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (upper)",
                                        "title": "Trendline upper confidence interval"
                                    },
                                    "count": {
                                        "description": "Number of non-null data points",
                                        "title": "Count"
                                    },
                                    "baseline": {
                                        "title": "Baseline",
                                        "description": "List of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "forecast_min": {
                                        "title": "Forecast minimum",
                                        "description": "Lower boundary of feasible forecast value range"
                                    },
                                    "trendline_strength": {
                                        "title": "Trendline strength",
                                        "description": "Coefficient of determination (R-squared) of the trendline"
                                    },
                                    "forecast_boundary_time": {
                                        "datatype": "time",
                                        "description": "Time forecast exceeds feasible value range if before end of timefilter range",
                                        "title": "Forecast boundary time"
                                    },
                                    "95th": {
                                        "description": "95th percentile of the data",
                                        "title": "95th percentile"
                                    },
                                    "forecast_daily_change": {
                                        "description": "The average daily change of forecast values",
                                        "title": "Forecast daily change"
                                    },
                                    "min": {
                                        "description": "Minimum data value",
                                        "title": "Minimum"
                                    },
                                    "forecast_max": {
                                        "title": "Forecast maximum",
                                        "description": "Upper boundary of feasible forecast value range"
                                    },
                                    "current": {
                                        "title": "Current",
                                        "description": "The current value"
                                    },
                                    "baseline_percent_compare": {
                                        "description": "Percentage difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Percent Comparison"
                                    },
                                    "start_tz_offset": {
                                        "datatype": "integer",
                                        "title": "Start TZ offset",
                                        "description": "The timezone offset of the first data point"
                                    },
                                    "forecast_vals": {
                                        "datatype": "array",
                                        "title": "Forecast values",
                                        "description": "An array of forecast values with periodic deviations at peak and offpeak times"
                                    },
                                    "max": {
                                        "title": "Maximum",
                                        "description": "Maximum data value"
                                    },
                                    "trendline_lwr": {
                                        "datatype": "array",
                                        "description": "Trendline confidence interval values (lower)",
                                        "title": "Trendline lower confidence interval"
                                    },
                                    "anomaly_strength": {
                                        "description": "Metric from 0 to 100 indicating whether requested timeseries values are extreme or unusual",
                                        "title": "Anomaly strength"
                                    },
                                    "forecast_predict_offpeak": {
                                        "description": "Long term prediction value calculated from historical data at offpeak times",
                                        "title": "Forecast prediction offpeak"
                                    },
                                    "start_time": {
                                        "datatype": "time",
                                        "title": "Start time",
                                        "description": "Time of the first data point"
                                    },
                                    "stddev": {
                                        "title": "Standard deviation",
                                        "description": "Standard deviation of the data"
                                    },
                                    "baseline_lwr": {
                                        "description": "List of baseline lower confidence interval values. Corresponds to -95% anomaly metric.",
                                        "title": "Baseline Lower Bound",
                                        "datatype": "array"
                                    },
                                    "trendline_percent_change": {
                                        "description": "Trendline change scaled by the average of data over requested time filter",
                                        "title": "Trendline percent change"
                                    },
                                    "vals": {
                                        "description": "Timeseries data values",
                                        "title": "Values",
                                        "datatype": "array"
                                    },
                                    "cvals": {
                                        "datatype": "array",
                                        "description": "Cumulative data values",
                                        "title": "Cumulative Values"
                                    },
                                    "last": {
                                        "title": "Last",
                                        "description": "The last value in the data"
                                    },
                                    "trendline_start": {
                                        "title": "Trendline Start",
                                        "description": "Value of the first trendline data point"
                                    },
                                    "forecast_fit": {
                                        "datatype": "array",
                                        "title": "Forecast fit",
                                        "description": "An array of forecast values without periodic deviations at peak and offpeak times"
                                    },
                                    "baseline_compare": {
                                        "description": "Difference between data average and expected baseline calculated from historical data",
                                        "title": "Baseline Comparison"
                                    },
                                    "first": {
                                        "title": "First",
                                        "description": "The first value in the data"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "description": "Custom percentile of the data"
                                    },
                                    "trendline_predict": {
                                        "title": "Trendline Predict",
                                        "description": "Prediction value from the trendline"
                                    },
                                    "trendline_change": {
                                        "description": "Trendline change over the requested timefilter range",
                                        "title": "Trendline change"
                                    },
                                    "baseline_upr": {
                                        "title": "Baseline Upper Bound",
                                        "description": "List of baseline upper confidence interval values. Corresponds to 95% anomaly metric.",
                                        "datatype": "array"
                                    },
                                    "avg": {
                                        "title": "Average",
                                        "description": "Average of the data"
                                    },
                                    "baseline_avg": {
                                        "description": "Average of expected baseline values calculated from historical data. Corresponds to 0% anomaly metric.",
                                        "title": "Baseline Average"
                                    },
                                    "trendline_finish": {
                                        "title": "Trendline Finish",
                                        "description": "Value of the last trendline data point"
                                    },
                                    "total": {
                                        "description": "Sum of the data",
                                        "title": "Total"
                                    },
                                    "forecast_predict": {
                                        "description": "Long term prediction value calculated from historical data",
                                        "title": "Forecast prediction"
                                    },
                                    "forecast_predict_peak": {
                                        "description": "Long term prediction value calculated from historical data at peak times",
                                        "title": "Forecast prediction peak"
                                    },
                                    "trendline_fit": {
                                        "description": "Trendline data values",
                                        "title": "Trendline fit",
                                        "datatype": "array"
                                    }
                                }
                            },
                            "stats": {
                                "values": {
                                    "forecast": {
                                        "values": {
                                            "min": {
                                                "description": "Manually set lower boundary of feasible forecast value range",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "title": "Minimum"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "default": "range = now - 180d to now",
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Timefilter for the historical data range used to calculate forecasts. Default is last 180 days.",
                                                "values": null
                                            },
                                            "predict_time": {
                                                "values": null,
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak"
                                                ],
                                                "description": "Time to use for the forecast_predict, forecast_predict_peak or forecast_predict_offpeak values (e.g. now + 10d)",
                                                "title": "Predict Time"
                                            },
                                            "max": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_slope",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "values": null,
                                                "description": "Manually set upper boundary of feasible forecast value range",
                                                "title": "Maximum"
                                            },
                                            "is_cumulative": {
                                                "valid_formats": [
                                                    "forecast_predict",
                                                    "forecast_predict_peak",
                                                    "forecast_predict_offpeak",
                                                    "forecast_min",
                                                    "forecast_max",
                                                    "forecast_boundary_time",
                                                    "forecast_daily_change",
                                                    "forecast_fit",
                                                    "forecast_vals"
                                                ],
                                                "description": "Whether to return the sum of forecast values",
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative"
                                            }
                                        },
                                        "description": "Forecast related input options"
                                    },
                                    "percentile": {
                                        "title": "Percentile",
                                        "values": null,
                                        "valid_formats": [
                                            "percentile"
                                        ],
                                        "description": "The value to use for the percentile format (between 0 and 100)"
                                    },
                                    "baseline": {
                                        "description": "Baseline and anomaly metric related input options",
                                        "values": {
                                            "percentile": {
                                                "description": "Baseline percentile to output",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline"
                                                ],
                                                "default": 50,
                                                "values": null,
                                                "title": "Percentile"
                                            },
                                            "data_range": {
                                                "title": "Baseline History",
                                                "description": "Timefilter for the historical data range used to calculate baseline and anomaly metric. Default is last 180 days.",
                                                "valid_formats": [
                                                    "baseline_avg",
                                                    "baseline_compare",
                                                    "baseline_percent_compare",
                                                    "baseline",
                                                    "baseline_lwr",
                                                    "baseline_upr",
                                                    "anomaly_metric",
                                                    "anomaly_strength"
                                                ],
                                                "default": "range = now - 180d to now",
                                                "values": null
                                            },
                                            "lwr_percentile": {
                                                "title": "Lower Percentile",
                                                "description": "Baseline percentile to output for baseline lower bound",
                                                "valid_formats": [
                                                    "baseline_lwr"
                                                ],
                                                "default": 2.5,
                                                "values": null
                                            },
                                            "upr_percentile": {
                                                "valid_formats": [
                                                    "baseline_upr"
                                                ],
                                                "default": 97.5,
                                                "values": null,
                                                "description": "Baseline percentile to output for baseline upper bound",
                                                "title": "Upper Percentile"
                                            }
                                        }
                                    },
                                    "trendline": {
                                        "description": "Trendline related input options",
                                        "values": {
                                            "lwr_stddev": {
                                                "valid_formats": [
                                                    "trendline_lwr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_lwr format",
                                                "values": null,
                                                "title": "Lower Standard Deviation"
                                            },
                                            "upr_stddev": {
                                                "title": "Upper Standard Deviation",
                                                "valid_formats": [
                                                    "trendline_upr"
                                                ],
                                                "description": "The number of standard deviations to use for the trendline_upr format",
                                                "values": null
                                            },
                                            "is_cumulative": {
                                                "description": "Whether to fit a trendline to the sum of the data values",
                                                "valid_formats": [
                                                    "trendline_fit",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "title": "Is Cumulative"
                                            },
                                            "predict_time": {
                                                "title": "Predict Time",
                                                "valid_formats": [
                                                    "trendline_predict"
                                                ],
                                                "values": null,
                                                "description": "The time to use for the trendline_predict value"
                                            },
                                            "constrained": {
                                                "valid_formats": [
                                                    "trendline_start",
                                                    "trendline_finish",
                                                    "trendline_daily_change",
                                                    "trendline_change",
                                                    "trendline_percent_change",
                                                    "trendline_predict"
                                                ],
                                                "values": [
                                                    true,
                                                    false
                                                ],
                                                "default": true,
                                                "description": "Whether to use a constrained trendline",
                                                "title": "Constrained"
                                            }
                                        },
                                        "title": "Trendline"
                                    }
                                },
                                "description": "Additional input options for certain formats"
                            },
                            "timefmt": {
                                "description": "Format a timestamp into a human readable string. Format specifier is identical to strftime(3)",
                                "values": null
                            }
                        }
                    },
                    "ping_state": {
                        "title": "Ping State",
                        "description": "The current ping state of the device",
                        "polltype": "evt",
                        "interval": 60,
                        "datatype": "string",
                        "enum": {
                            "1": {
                                "label": "up",
                                "description": "Device is up"
                            },
                            "2": {
                                "label": "down",
                                "description": "Device is down"
                            }
                        },
                        "options": {
                            "formats": {
                                "description": "The valid data formats",
                                "values": {
                                    "avl_outTransitions": {
                                        "title": "Transitions out of states",
                                        "datatype": "integer",
                                        "description": "The number of transitions from a state that wasn't request to a requested state"
                                    },
                                    "avl_inTransitions": {
                                        "description": "The number of transitions from one of the requested states to a state not requested",
                                        "datatype": "integer",
                                        "title": "Transitions into states"
                                    },
                                    "avl_outTime": {
                                        "title": "Time not in states",
                                        "description": "The time the event has not been in any of the requested states",
                                        "datatype": "integer"
                                    },
                                    "avl_inTime": {
                                        "title": "Time in states",
                                        "datatype": "float",
                                        "description": "The time the event has been in any of the requested states"
                                    },
                                    "state_inTime": {
                                        "description": "The number of seconds that the current state has been active",
                                        "datatype": "integer",
                                        "title": "Time in current state"
                                    },
                                    "avl_outPercent": {
                                        "title": "Percent not in states",
                                        "description": "The percent of time the event has not been in any of the states",
                                        "datatype": "float"
                                    },
                                    "avl_inPercent": {
                                        "datatype": "float",
                                        "description": "The percent of time the event has been in any of the requested states",
                                        "title": "Percent in states"
                                    },
                                    "state_id": {
                                        "description": "The current state identifier of the event",
                                        "datatype": "integer",
                                        "title": "State ID"
                                    },
                                    "state_delta": {
                                        "title": "Time in previous state",
                                        "description": "The number of seconds to the previous record",
                                        "datatype": "integer"
                                    },
                                    "avl_totalTransitions": {
                                        "title": "Total transitions",
                                        "datatype": "integer",
                                        "description": "The total number of transition between all of the states"
                                    },
                                    "state_time": {
                                        "datatype": "time",
                                        "description": "The time of the last transition",
                                        "title": "Time of last transition"
                                    },
                                    "poll": {
                                        "title": "Poll",
                                        "description": "Whether polling is enabled for the event",
                                        "datatype": "string"
                                    },
                                    "state": {
                                        "datatype": "string",
                                        "description": "The current state of the event",
                                        "title": "State"
                                    }
                                }
                            },
                            "states": {
                                "values": null,
                                "description": "Array of state names to use for the calculations"
                            }
                        }
                    },
                    "priv_method": {
                        "title": "SNMPv3 Privacy Method",
                        "description": "Privacy method for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "priv_pass": {
                        "title": "SNMPv3 Privacy Password",
                        "description": "Privacy password for SNMPv3 devices",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "retired": {
                        "title": "Retired",
                        "description": "The device has been Retired",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "snmpEngineID": {
                        "title": "SNMP Engine ID",
                        "description": "An SNMP engine's administratively-unique identifier",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "snmp_maxoid": {
                        "title": "SNMP Max OID",
                        "description": "Maximum number of oids to poll in a single request",
                        "polltype": "cfg",
                        "datatype": "integer"
                    },
                    "snmp_poll": {
                        "title": "SNMP Poll",
                        "description": "The SNMP polling status of the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "snmp_version": {
                        "title": "SNMP Version",
                        "description": "The SNMP version of the device",
                        "polltype": "cfg",
                        "datatype": "integer"
                    },
                    "sysContact": {
                        "title": "Contact",
                        "description": "The textual identification of the contact person for the entity",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "sysDescr": {
                        "title": "System Description",
                        "description": "A textual description of the entity",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "sysLocation": {
                        "title": "Location",
                        "description": "The physical location of the entity",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "sysName": {
                        "title": "System Name",
                        "description": "An administratively-assigned name for the entity",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "sysObjectID": {
                        "title": "Object ID",
                        "description": "The vendor's authoritative identification of the network management subsystem contained in the entity",
                        "polltype": "cfg",
                        "datatype": "string"
                    },
                    "sysServices": {
                        "title": "Services",
                        "description": "A value which indicates the set of services that the entity may potentially offer",
                        "polltype": "cfg",
                        "datatype": "integer"
                    },
                    "vendor": {
                        "title": "Vendor",
                        "description": "The vendor name for the device",
                        "polltype": "cfg",
                        "datatype": "string"
                    }
                },
                "commands": {
                    "add": {
                        "valid_fields": null,
                        "valid_data": {
                            "ipaddress": {
                                "required": true
                            },
                            "community": {
                                "required": false
                            },
                            "hostname": {
                                "required": false
                            },
                            "snmp_version": {
                                "required": false
                            },
                            "auth_method": {
                                "required": false
                            },
                            "auth_user": {
                                "required": false
                            },
                            "auth_pass": {
                                "required": false
                            },
                            "priv_method": {
                                "required": false
                            },
                            "priv_pass": {
                                "required": false
                            },
                            "context": {
                                "required": false
                            },
                            "snmp_poll": {
                                "required": false
                            },
                            "ping_poll": {
                                "required": false
                            },
                            "longitude": {
                                "required": false
                            },
                            "latitude": {
                                "required": false
                            }
                        }
                    },
                    "update": {
                        "valid_fields": {
                            "id": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "deviceid": {
                                "required": false
                            },
                            "idx": {
                                "required": false
                            },
                            "table": {
                                "required": false
                            },
                            "poll": {
                                "required": false
                            },
                            "auth_method": {
                                "required": false
                            },
                            "auth_pass": {
                                "required": false
                            },
                            "auth_user": {
                                "required": false
                            },
                            "community": {
                                "required": false
                            },
                            "context": {
                                "required": false
                            },
                            "custom_data_details": {
                                "required": false
                            },
                            "discover_getNext": {
                                "required": false
                            },
                            "discover_minimal": {
                                "required": false
                            },
                            "discover_snmpv1": {
                                "required": false
                            },
                            "hostname": {
                                "required": false
                            },
                            "ipaddress": {
                                "required": false
                            },
                            "latitude": {
                                "required": false
                            },
                            "longitude": {
                                "required": false
                            },
                            "manual_name": {
                                "required": false
                            },
                            "memorySize": {
                                "required": false
                            },
                            "mis": {
                                "required": false
                            },
                            "ping_dup": {
                                "required": false
                            },
                            "ping_lost1": {
                                "required": false
                            },
                            "ping_lost2": {
                                "required": false
                            },
                            "ping_lost3": {
                                "required": false
                            },
                            "ping_lost4": {
                                "required": false
                            },
                            "ping_outage": {
                                "required": false
                            },
                            "ping_poll": {
                                "required": false
                            },
                            "ping_rtt": {
                                "required": false
                            },
                            "ping_rtt_ms": {
                                "required": false
                            },
                            "ping_state": {
                                "required": false
                            },
                            "priv_method": {
                                "required": false
                            },
                            "priv_pass": {
                                "required": false
                            },
                            "retired": {
                                "required": false
                            },
                            "snmpEngineID": {
                                "required": false
                            },
                            "snmp_maxoid": {
                                "required": false
                            },
                            "snmp_poll": {
                                "required": false
                            },
                            "snmp_version": {
                                "required": false
                            },
                            "sysContact": {
                                "required": false
                            },
                            "sysDescr": {
                                "required": false
                            },
                            "sysLocation": {
                                "required": false
                            },
                            "sysName": {
                                "required": false
                            },
                            "sysObjectID": {
                                "required": false
                            },
                            "sysServices": {
                                "required": false
                            },
                            "vendor": {
                                "required": false
                            }
                        },
                        "valid_data": {
                            "poll": {
                                "required": false
                            },
                            "auth_method": {
                                "required": false
                            },
                            "auth_pass": {
                                "required": false
                            },
                            "auth_user": {
                                "required": false
                            },
                            "community": {
                                "required": false
                            },
                            "context": {
                                "required": false
                            },
                            "custom_data_details": {
                                "required": false
                            },
                            "discover_getNext": {
                                "required": false
                            },
                            "discover_minimal": {
                                "required": false
                            },
                            "discover_snmpv1": {
                                "required": false
                            },
                            "hostname": {
                                "required": false
                            },
                            "ipaddress": {
                                "required": false
                            },
                            "latitude": {
                                "required": false
                            },
                            "longitude": {
                                "required": false
                            },
                            "manual_name": {
                                "required": false
                            },
                            "mis": {
                                "required": false
                            },
                            "ping_outage": {
                                "required": false
                            },
                            "ping_poll": {
                                "required": false
                            },
                            "ping_state": {
                                "required": false
                            },
                            "priv_method": {
                                "required": false
                            },
                            "priv_pass": {
                                "required": false
                            },
                            "snmpEngineID": {
                                "required": false
                            },
                            "snmp_maxoid": {
                                "required": false
                            },
                            "snmp_poll": {
                                "required": false
                            },
                            "snmp_version": {
                                "required": false
                            },
                            "sysContact": {
                                "required": false
                            },
                            "sysDescr": {
                                "required": false
                            },
                            "sysLocation": {
                                "required": false
                            },
                            "sysName": {
                                "required": false
                            },
                            "sysObjectID": {
                                "required": false
                            },
                            "sysServices": {
                                "required": false
                            }
                        }
                    },
                    "delete": {
                        "valid_fields": {
                            "id": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "deviceid": {
                                "required": false
                            },
                            "idx": {
                                "required": false
                            },
                            "table": {
                                "required": false
                            },
                            "poll": {
                                "required": false
                            },
                            "auth_method": {
                                "required": false
                            },
                            "auth_pass": {
                                "required": false
                            },
                            "auth_user": {
                                "required": false
                            },
                            "community": {
                                "required": false
                            },
                            "context": {
                                "required": false
                            },
                            "custom_data_details": {
                                "required": false
                            },
                            "discover_getNext": {
                                "required": false
                            },
                            "discover_minimal": {
                                "required": false
                            },
                            "discover_snmpv1": {
                                "required": false
                            },
                            "hostname": {
                                "required": false
                            },
                            "ipaddress": {
                                "required": false
                            },
                            "latitude": {
                                "required": false
                            },
                            "longitude": {
                                "required": false
                            },
                            "manual_name": {
                                "required": false
                            },
                            "memorySize": {
                                "required": false
                            },
                            "mis": {
                                "required": false
                            },
                            "ping_dup": {
                                "required": false
                            },
                            "ping_lost1": {
                                "required": false
                            },
                            "ping_lost2": {
                                "required": false
                            },
                            "ping_lost3": {
                                "required": false
                            },
                            "ping_lost4": {
                                "required": false
                            },
                            "ping_outage": {
                                "required": false
                            },
                            "ping_poll": {
                                "required": false
                            },
                            "ping_rtt": {
                                "required": false
                            },
                            "ping_rtt_ms": {
                                "required": false
                            },
                            "ping_state": {
                                "required": false
                            },
                            "priv_method": {
                                "required": false
                            },
                            "priv_pass": {
                                "required": false
                            },
                            "retired": {
                                "required": false
                            },
                            "snmpEngineID": {
                                "required": false
                            },
                            "snmp_maxoid": {
                                "required": false
                            },
                            "snmp_poll": {
                                "required": false
                            },
                            "snmp_version": {
                                "required": false
                            },
                            "sysContact": {
                                "required": false
                            },
                            "sysDescr": {
                                "required": false
                            },
                            "sysLocation": {
                                "required": false
                            },
                            "sysName": {
                                "required": false
                            },
                            "sysObjectID": {
                                "required": false
                            },
                            "sysServices": {
                                "required": false
                            },
                            "vendor": {
                                "required": false
                            }
                        },
                        "valid_data": null
                    },
                    "get": {
                        "valid_fields": {
                            "id": {
                                "required": false
                            },
                            "name": {
                                "required": false
                            },
                            "deviceid": {
                                "required": false
                            },
                            "idx": {
                                "required": false
                            },
                            "table": {
                                "required": false
                            },
                            "poll": {
                                "required": false
                            },
                            "auth_method": {
                                "required": false
                            },
                            "auth_pass": {
                                "required": false
                            },
                            "auth_user": {
                                "required": false
                            },
                            "community": {
                                "required": false
                            },
                            "context": {
                                "required": false
                            },
                            "custom_data_details": {
                                "required": false
                            },
                            "discover_getNext": {
                                "required": false
                            },
                            "discover_minimal": {
                                "required": false
                            },
                            "discover_snmpv1": {
                                "required": false
                            },
                            "hostname": {
                                "required": false
                            },
                            "ipaddress": {
                                "required": false
                            },
                            "latitude": {
                                "required": false
                            },
                            "longitude": {
                                "required": false
                            },
                            "manual_name": {
                                "required": false
                            },
                            "memorySize": {
                                "required": false
                            },
                            "mis": {
                                "required": false
                            },
                            "ping_dup": {
                                "required": false
                            },
                            "ping_lost1": {
                                "required": false
                            },
                            "ping_lost2": {
                                "required": false
                            },
                            "ping_lost3": {
                                "required": false
                            },
                            "ping_lost4": {
                                "required": false
                            },
                            "ping_outage": {
                                "required": false
                            },
                            "ping_poll": {
                                "required": false
                            },
                            "ping_rtt": {
                                "required": false
                            },
                            "ping_rtt_ms": {
                                "required": false
                            },
                            "ping_state": {
                                "required": false
                            },
                            "priv_method": {
                                "required": false
                            },
                            "priv_pass": {
                                "required": false
                            },
                            "retired": {
                                "required": false
                            },
                            "snmpEngineID": {
                                "required": false
                            },
                            "snmp_maxoid": {
                                "required": false
                            },
                            "snmp_poll": {
                                "required": false
                            },
                            "snmp_version": {
                                "required": false
                            },
                            "sysContact": {
                                "required": false
                            },
                            "sysDescr": {
                                "required": false
                            },
                            "sysLocation": {
                                "required": false
                            },
                            "sysName": {
                                "required": false
                            },
                            "sysObjectID": {
                                "required": false
                            },
                            "sysServices": {
                                "required": false
                            },
                            "vendor": {
                                "required": false
                            }
                        },
                        "valid_data": null
                    },
                    "describe": {
                        "valid_fields": null,
                        "valid_data": null
                    }
                },
                "info": {
                    "tags": [],
                    "licenced": false,
                    "vendor": "Standard",
                    "category": "Device",
                    "inherited_by": [
                        "cdt_device_apic",
                        "cdt_device_freebsd"
                    ],
                    "inherits": null,
                    "allow_grouping": 1,
                    "allow_reporting": 1,
                    "allow_discovery": 0,
                    "poller": "snmp"
                },
                "allow_formula_fields": true,
                "links": {
                    "macLink": {
                        "title": "Link to MAC",
                        "object": "mac",
                        "default": 1
                    }
                },
                "global_field_options": {
                    "aggregation_format": {
                        "description": "Aggregation formats to apply when group_by option is provided",
                        "values": {
                            "first": {
                                "title": "First",
                                "description": "First value in the group (default)"
                            },
                            "last": {
                                "title": "Last",
                                "description": "Last value in the group"
                            },
                            "avg": {
                                "title": "Average",
                                "description": "Average of the values in the group"
                            },
                            "count": {
                                "title": "Count",
                                "description": "Number on non-null values in the group"
                            },
                            "count_all": {
                                "title": "Count (include NULL)",
                                "description": "Number of values in the group (including null values)"
                            },
                            "count_unique": {
                                "title": "Unique count",
                                "description": "Number of unique non-null values in the group"
                            },
                            "count_unique_all": {
                                "title": "Unique count (include NULL)",
                                "description": "Number of unique values in the group (including null values)"
                            },
                            "cat": {
                                "title": "Concatenate",
                                "description": "Concatenation of the values in the group"
                            },
                            "list": {
                                "title": "List",
                                "description": "Comma separated concatenation of the values in the group"
                            },
                            "list_unique": {
                                "title": "Unique List",
                                "description": "Comma separated concatenation of the unique values in the group"
                            },
                            "min": {
                                "title": "Minimum",
                                "description": "Minimum of the values in the group"
                            },
                            "max": {
                                "title": "Maximum",
                                "description": "Maximum of the values in the group"
                            },
                            "sum": {
                                "title": "Sum",
                                "description": "Sum of all values in the group (null if no valid values)"
                            },
                            "total": {
                                "title": "Total",
                                "description": "Sum of all values in the group (0 if no valid values)"
                            },
                            "median": {
                                "title": "Median",
                                "description": "Median of the values in the group"
                            },
                            "95th": {
                                "title": "95th percentile",
                                "description": "95th percentile of the values in the group"
                            },
                            "stddev": {
                                "title": "Standard deviation",
                                "description": "Standard deviation of the values in the group"
                            }
                        }
                    }
                }
            }
        ]
    },
    "links": [
        {
            "link": "/api/v2.1/cdt_device/describe",
            "rel": "self"
        },
        {
            "link": "/api/v2.1",
            "rel": "base"
        },
        {
            "link": "/api/v2.1/cdt_device",
            "rel": "collection"
        }
    ]
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server/api/v2.1/discover/execute/?mode=single&ip=10.100.89.252&verbose=0&links=none" 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/discover/execute/'
# specify options
query += '?mode=single&ip=10.100.89.252&verbose=0'
query += '&indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user/describe'
# specify options
$query += "/?mode=single&ip=10.100.89.252&verbose=0"
# optional response formatting
$query += '&indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
    "version": "2.1",
    "revision": "13",
    "info": "The Statseeker RESTful API",
    "data": {
        "success": true,
        "errmsg": "ok",
        "time": 1575867957,
        "objects": [
            {
                "type": "discover",
                "sequence": 1,
                "status": {
                    "success": true,
                    "errcode": 0
                }
            }
        ]
    }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server/api/v2.1/discover/execute/?mode=snmpv3add&snmpv3config=/path/to/config.csv&verbose=0&links=none" 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/discover/execute/'
# specify options
query += '?mode=snmpv3add&snmpv3config=/path/to/config.csv&verbose=0'
query += '&indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user/describe'
# specify options
$query += "?mode=snmpv3add&snmpv3config=/path/to/config.csv&verbose=0"
# optional response formatting
$query += '&indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
    "version": "2.1",
    "revision": "13",
    "info": "The Statseeker RESTful API",
    "data": {
        "success": true,
        "errmsg": "ok",
        "time": 1575867957,
        "objects": [
            {
                "type": "discover",
                "sequence": 1,
                "status": {
                    "success": true,
                    "errcode": 0
                }
            }
        ]
    }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server/api/v2.1/cdt_device/<DEVICE ID>/?fields=name,id,community,ipaddress,snmp_version&indent=3" 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp
# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/cdt_device/<DEVICE ID>'
# specify fields to be returned
query += '/?fields=name,id,community,ipaddress,snmp_version'
# optional response formatting
query += '&indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/cdt_device/<DEVICE ID>'
# specify fields to be returned
$query += '/?fields=name,id,community,ipaddress,snmp_version'
# optional response formatting
$query += '&indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
    "version": "2.1",
    "revision": "13",
    "info": "The Statseeker RESTful API",
    "data": {
        "success": true,
        "errmsg": "ok",
        "time": 1623636846,
        "objects": [
            {
                "type": "cdt_device",
                "sequence": 0,
                "status": {
                    "success": true,
                    "errcode": 0
                },
                "data_total": 1,
                "data": [
                    {
                        "name": "Chicago-srv1",
                        "id": <DEVICE ID>,
                        "community": "public",
                        "ipaddress": "10.100.46.11",
                        "snmp_version": 2
                    }
                ]
            }
        ]
    }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X PUT \
	"https://your.statseeker.server/api/v2.1/group/<GROUP ID>/?indent=3" \
	-d '{"data":[{"name":"<NEW NAME>"}]}' 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.put(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.put(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/group/<GROUP ID>'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"data":[{"name":"<NEW NAME>"}]})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :put,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :put,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/group/<GROUP ID>'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"data":[{"name":"<NEW NAME>"}]}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623637436
   }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X DELETE \
	"https://your.statseeker.server/api/v2.1/group/<GROUP ID>/?indent=3"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.delete(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.delete(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/group/<GROUP ID>'
# optional response formatting
query += '/?indent=3&links=none'
# data
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}') 

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :delete,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :delete,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/group/<GROUP ID>'
# optional response formatting
$query += '/?indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623637436
   }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X GET \
	"https://your.statseeker.server/api/v2.1/user/<USER ID>/tz/?indent=3"

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.get(url, headers=headers, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.get(url, headers=headers, auth=(user, pword), verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/user/<USER ID>/tz'
# optional response formatting
query += '/?indent=3&links=none'
# Run the request
resp = do_request(server, query, user, pword)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}') 

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword)
	headers = {
		:content_type => "json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :get,
		:url => url,
		:headers => headers,
		:verify_ssl => false
	)
end

def do_request(server, query, user, pword)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword)
    else
        # Authentication successful. Statseeker at least v5.5.4
        headers = {
			:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
            :method => :get,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user/<USER ID>/tz'
# optional response formatting
$query += '/?indent=3&links=none'
# Run the request
resp = do_request($server, $query, $user, $pword)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623638836,
      "objects":[
         {
            "type":"user",
            "sequence":0,
            "status":{
               "success":true,
               "errcode":0
            },
            "data_total":1,
            "data":[
               {
                  "tz":"Australia/Brisbane",
                  "id":<USER ID>
               }
            ]
         }
      ]
   }
}

curl \
	-H "Accept: application/json" \
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X PUT \
	"https://your.statseeker.server/api/v2.1/user/<USER ID>/tz/?indent=3" \
	-d '{"value":"Europe/Paris"}'

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.put(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.put(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/user/<USER ID>/tz'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"value":"Europe/Paris"})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :put,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :put,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user/<USER ID>/tz'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"value":"Europe/Paris"}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
  "info": "The Statseeker RESTful API",
  "data": {
    "errmsg": "ok",
    "success": true,
    "time": 1496193864
  },
  "api_version": "2.1"
}

curl \ 
	-H "Accept: application/json" \ 
	-H "Content-Type: application/json" \
	-X POST \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	"https://your.statseeker.server/api/v2.1/user/?indent=3" \
	-d '{"data":[{"name":"<USER NAME>","password":"<PASSWORD>","auth":"<AUTHENTICATION METHOD>","email":"<EMAIL ADDRESS>","api":"<API PERMISSION>","tz":"<TIMEZONE>"}]}' 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.post(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.post(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/user'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"data":[{"name":"<USER NAME>","password":"<PASSWORD>","auth":"<AUTHENTICATION METHOD>","email":"<EMAIL ADDRESS>","api":"<API PERMISSION>","tz":"<TIMEZONE>"}]})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}') 

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :post,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :post,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
# define payload in json format
$reqData = '{"data":[{"name":"<USER NAME>","password":"<PASSWORD>","auth":"<AUTHENTICATION METHOD>","email":"<EMAIL ADDRESS>","api":"<API PERMISSION>","tz":"<TIMEZONE>"}]}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623643182,
      "objects":[
         {
            "type":"user",
            "sequence":1,
            "status":{
               "success":true,
               "errcode":0
            },
            "data_total":1,
            "data":[
                  "api":"<API PERMISSION>",
                  "auth":"<AUTHENTICATION METHOD>",
                  "email":"<EMAIL ADDRESS>",
                  "name":"<USER NAME>",
                  "password":"<PASSWORD>",
                  "tz":"<TIMEZONE>",
                  "id":94551,
                  "is_admin":0
               }
            ]
         }
      ]
   }
}

curl \ 
	-H "Accept: application/json" \ 
	-H "Content-Type: application/json" \
	-H "Authorization: Bearer <YOUR_AUTH_TOKEN>" \
	-X PUT \
	"https://your.statseeker.server/api/v2.1/user/<USER ID>?indent=3" \
	-d '{"data":[{"api":"<API PERMISSION>","tz":"<NEW TIMEZONE>"}]}' 

# import requests for handling connection and encoding
import requests
import json
def do_request(server, query, user, pword, reqData):
    # Run auth request
    headers = { 'Accept': 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' }
    url = f'https://{server}/ss-auth'
    authData = {'user': user, 'password': pword}
    resp = requests.post(url, headers=headers, data=authData, verify=False)
    headers['Content-Type'] = 'application/json'
    url = f'https://{server}/{query}'
    print(f'Get Auth Token: {resp.status_code}')
    if resp.status_code == 200:    
        # Authentication successful, Statseeker >= v5.5.4
        myToken = resp.json()
        headers['Authorization'] = f'Bearer {myToken["access_token"]}'
        resp = requests.put(url, headers=headers, data=reqData, verify=False)
    if resp.status_code == 401:
        print(f'Token auth failed: {resp.status_code}, trying basic auth')
        # Either Authentication was unsuccessful (Statseeker <  v5.5.4), or API set to use basic auth
        # Try basic auth
        resp = requests.put(url, headers=headers, auth=(user, pword), data=reqData, verify=False)
    return resp

# Statseeker Server IP
server = 'your.statseeker.server'
# credentials
user = 'api_user'
pword = 'user_password'
# API root endpoint
query = 'api/v2.1'
# specify target endpoint
query += '/user/<USER ID>'
# optional response formatting
query += '/?indent=3&links=none'
# data
reqData = json.dumps({"data":[{"api":"<API PERMISSION>","tz":"<NEW TIMEZONE>"}]})
# Run the request
resp = do_request(server, query, user, pword, reqData)
if resp.status_code == 200:
    print(resp.status_code)
    print(resp.json())
else:
    print(f'Error: {resp.status_code} {resp.reason}')

# install with: $ gem install rest-client
require "rest_client"
require "json"
require "base64"

def try_basic(server, query, user, pword, reqData)
	headers = {
		:content_type => "application/json"
	}
	url = "https://" + server + "/" + query
	headers["Authorization"] = "Basic " + Base64.encode64("#{user}:#{pword}")
	return RestClient::Request.execute(
		:method => :put,
		:url => url,
		:headers => headers,
		:verify_ssl => false,
		:payload => reqData
	)
end

def do_request(server, query, user, pword, reqData)
    # Run auth request
    headers = {
        :content_type => "application/x-www-form-urlencoded"
    }
    url = "https://" + server + "/ss-auth"
    authData = {
       :user => user,
       :password => pword
    }
    begin
        resp = RestClient::Request.execute(
            :method => :post,
            :url => url,
            :headers => headers,
            :verify_ssl => false,
            :payload => authData
        )
    rescue RestClient::Unauthorized
		# bad credentials or Statseeker not v5.5.4 or higher
        try_basic(server, query, user, pword, reqData)
    else		
        # Authentication successful. Statseeker at least v5.5.4
		headers = {
		:content_type => "application/json"
		}	
        url = "https://" + server + "/" + query
        rdata = JSON.parse(resp)
        headers["Authorization"] = "Bearer " + rdata.fetch("access_token")
        return RestClient::Request.execute(
			:method => :put,
			:url => url,
			:headers => headers,
			:verify_ssl => false,
			:payload => reqData
        )
    end
	rescue RestClient::Unauthorized
		# Statseeker = v5.5.4 but configured for basic auth
        try_basic(server, query, user, pword, reqData)
end
# Statseeker Server IP
$server = 'your.statseeker.server'
# api user credentials
$user = 'api_user'
$pword = 'user_password'
# api root endpoint
$query = 'api/v2.1'
# specify target endpoint
$query += '/user/<USER ID>'
# optional response formatting
$query += '/?indent=3&links=none'
# configure payload
$reqData = '{"data":[{"api":"<API PERMISSION>","tz":"<NEW TIMEZONE>"}]}'
# Run the request
resp = do_request($server, $query, $user, $pword, $reqData)
puts "#{resp.to_str}"

{
   "version":"2.1",
   "revision":"11",
   "info":"The Statseeker RESTful API",
   "data":{
      "success":true,
      "errmsg":"ok",
      "time":1623644832
   }
}