Ice Blue Digital

Connect

Bright Wire Studio API

Bright Wire Studio offers a suite of machine learning and natural language processing services - accessible through a single API.

API clients are currently available for .net and JavaScript.

Create an account to get an API key that you can use when Bright Wire Studio becomes publicly available.

Account

[GET] /api/account/subscription => SubscriptionInfo[]

Returns the current list of your active subscriptions

[GET] /api/account/usage => AccountUsage

Returns information on your usage history

WordNet

[GET] /api/wordnet/search?q={query} => WordnetSearchResults

Searches WordNet for senses with the given word. If not found, near matches are returned.

ParameterTypeDescription
querystringWord to query

[GET] /api/wordnet/{sid} => SenseIndex

Returns a WordNet sense index

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/expanded => ExpandedSenseIndex

Returns an expanded WordNet sense index

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/hypernyms => uint[]

Returns sense hypernyms (ancestors)

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/hyponyms => uint[]

Returns sense hyponyms (descendants)

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/holonyms => uint[]

Returns sense index holonyms (of which the sense is a part of)

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/meronyms => uint[]

Returns sense index meronyms (parts of)

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/coordinateterms => uint[]

Returns sense index coordinate terms

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/related => uint[]

Returns related sense indices

ParameterTypeDescription
sidunsigned integerSense index id to query

[GET] /api/wordnet/{sid}/topics?s={start}&c={count} => TopicInfo[]

Returns topics associated with a sense index

ParameterTypeDescription
sidunsigned integerSense index id to query
startunsigned integerStart offset (from 0)(optional)
countunsigned integerResult count (max 500)(optional)

Topics

[GET] /api/topic/count => unsigned integer

Returns the total number of topics

[GET] /api/topic/{topicId} => TopicInfo

Returns a topic based on id

ParameterTypeDescription
topicIdunsigned integerTopic id

[GET] /api/topic?tid={topicIds} => TopicInfo[]

Returns a list of topics

ParameterTypeDescription
topicIdsstringPipe separated list of topic ids

[GET] /api/topic?cid={category}&s={start}&c={count} => TopicInfo[]

Returns topics associated with the topic category

ParameterTypeDescription
categorystringCategory name to query
startunsigned integerStart offset (from 0)(optional)
countunsigned integerResult count (max 500)(optional)

[GET] /api/topic?sid={senseIndex}&s={start}&c={count} => TopicInfo[]

Returns topics associated with the given WordNet sense index

ParameterTypeDescription
senseIndexunsigned integerSense index to query
startunsigned integerStart offset (from 0)(optional)
countunsigned integerResult count (max 500)(optional)

[GET] /api/topic/search?q={query}&s={start}&c={count} => PagedResponse of SemanticResult

Searches the topic ontology for the named topic. Returns matching topics, categories and sense indices.

ParameterTypeDescription
querystringThe topic to search for
startunsigned integerStart offset (from 0)(optional)
countunsigned integerResult count (max 500)(optional)

Jobs

[GET] /api/job => JobInfo[]

Returns a list of lodged jobs

[GET] /api/job/{id}/status => string

Returns the status of a particular job

ParameterTypeDescription
idstringJob id

[DELETE] /api/job/{id} => StatusMessage

Deletes a job

ParameterTypeDescription
idstringJob id

[POST] /api/job/tokenise => JobInfo

Lodges a tokenise job

Message Body

Text to parse

[GET] /api/job/tokenise/{id} => SimpleToken[]

Returns the tokens found

ParameterTypeDescription
idstringJob id

[POST] /api/job/pos => JobInfo

Lodges a parts of speech job

Message Body

Text to parse

[GET] /api/job/pos/{id} => Sentence[]

Returns the parts of speech found

ParameterTypeDescription
idstringJob id

[POST] /api/job/syntax => JobInfo

Lodges a synatic analysis job

Message Body

Text to parse

[GET] /api/job/syntax/{id} => Token[]

Returns the tokens found

ParameterTypeDescription
idstringJob id

[POST] /api/job/sentiment => JobInfo

Lodges a sentiment analysis job

Message Body

Text to parse

[GET] /api/job/sentiment/{id} => Sentence[]

Returns the sentences found and their sentiment

ParameterTypeDescription
idstringJob id

[POST] /api/job/semantic => JobInfo

Lodges a semantic analysis job

Message Body

Text to parse

[GET] /api/job/semantic/{id} => Token[]

Returns the tokens found

ParameterTypeDescription
idstringJob id

[POST] /api/job/embedding => JobInfo

Lodges an embedding query job

Message Body

Text to query (for example "queen -woman +man")

[GET] /api/job/embedding/{id} => WordEmbeddingResponse

Returns the embedding response

ParameterTypeDescription
idstringJob id

[POST] /api/job/qa => JobInfo

Lodges a question analysis job

Message Body

Text of question to analyse

[GET] /api/job/qa/{id} => QuestionAnalysisResults

Gets question analysis output

ParameterTypeDescription
idstringJob id

Data Tables

[POST] /api/table?name={documentName}&sep={separator} => AddDataTableResponse

Adds a data table from CSV

Message Body

File content

ParameterTypeDescription
documentNamestringFile name
separatorstringColumn separator

[GET] /api/table/list?s={start}&c={count} => PagedResponse of DataTableInfo

Returns a list of data tables

ParameterTypeDescription
startunsigned integerStart index(optional)
countunsigned integerCount to return(optional)

[GET] /api/table/{id} => DataTableInfo

Returns information about a data table

ParameterTypeDescription
idstringData table id

[GET] /api/table/{id}/data?s={start}&c={count} => DataTableData

Returns a page of data from a data table

ParameterTypeDescription
idstringData table id
startunsigned integerFirst row index to return(optional)
countunsigned integerCount of rows to return(optional)

[PUT] /api/table/{id} => StatusMessage

Updates the data table meta data

Message Body

Data table definition

ParameterTypeDescription
idstringData table id

[POST] /api/table/{id}/column/target?cid={columnIndex} => StatusMessage

Updates the table's classification target column

ParameterTypeDescription
idstringData table id
columnIndexintColumn index to set as the classification target

[POST] /api/table/{id}/column/name?cid={columnIndex}&name={newName} => StatusMessage

Updates a data table column name

ParameterTypeDescription
idstringData table id
columnIndexintColumn index to update
newNamestringNew column name

[DELETE] /api/table/{id} => bool

Deletes the data table

ParameterTypeDescription
idstringData table id

Analysis

[POST] /api/analysis/text => TextAnalysisResults

Performs a semantic analysis on the text

Message Body

The text to analyse

[GET] /api/analysis/query?q={query} => QueryWord[]

Analyses a search query

ParameterTypeDescription
querystringSearch query text

[GET] /api/analysis/related?d={documentId}&p={paragraphIds}&s={start}&c={count} => Related

Finds related paragraphs

ParameterTypeDescription
documentIdstringDocument id
paragraphIdsstringPipe separated list of paragraph ids
startunsigned integerStart offset(optional)
countunsigned integerResult count(optional)

[POST] /api/analysis/related?s={start}&c={count} => Related

Finds paragraphs related to the text

Message Body

Text to analyse

ParameterTypeDescription
startunsigned integerStart offset(optional)
countunsigned integerResult count(optional)

[GET] /api/analysis/related?q={paragraphIds}&s={start}&c={count} => Related

Finds related paragraphs

ParameterTypeDescription
paragraphIdsstringPipe separated list of document:paragraph ids. For example doc1:1,2|doc2:3 specifies the first and second paragraph in doc1 with the third paragraph in doc2
startunsigned integerStart offset(optional)
countunsigned integerResult count(optional)

[GET] /api/analysis/topics?q={query}&s={start}&c={count} => PagedResponse of SemanticResult

Search topics that are associated with documents

ParameterTypeDescription
querystringSearch query
startunsigned integerStart offset(optional)
countunsigned integerResult count(optional)

Documents

[GET] /api/document?title={documentTitle} => DocumentInfo

Returns document meta data

ParameterTypeDescription
documentTitlestringDocument title

[GET] /api/document/tags => string[]

Returns all document tags

[GET] /api/document/{id} => DocumentInfo

Returns information about a single document

ParameterTypeDescription
idstring-

[GET] /api/document/list?s={start}&c={count}&q={query}&t={tags}&f={flagged} => PagedResponse of DocumentInfo

Returns a page of documents

ParameterTypeDescription
startunsigned integerStart offset(optional)
countunsigned integerCount of documents to return(optional)
querystringOptional search query(optional)
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolTrue to only return flagged documents(optional)

[GET] /api/document/{id}/data => string

Returns document JSON

ParameterTypeDescription
idstringDocument id

[GET] /api/document/data?title={documentTitle} => string

Returns document JSON

ParameterTypeDescription
documentTitlestringDocument title

[POST] /api/document/{id}/data => StatusMessage

Updates document JSON

Message Body

Document JSON

ParameterTypeDescription
idstringDocument id

[POST] /api/document/{id}/append?url={fromUrl} => StatusMessage

Appends static html to a document

Message Body

HTML to append

ParameterTypeDescription
idstringDocument id
fromUrlstringUrl that the HTML came from

[GET] /api/document/{id}/related/documents?t={tags}&f={flagged} => Related

Gets documents related to the specified document

ParameterTypeDescription
idstringDocument id
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

[GET] /api/document/{id}/related/paragraphs?pid={paragraphIds}&s={start}&c={count} => Related

Gets document paragraphs that are related to the selected list of paragraphs

ParameterTypeDescription
idstringDocument id
paragraphIdsstringPipe separated list of paragraph ids
startunsigned integerStart offset(optional)
countunsigned integerParagraph count(optional)

[GET] /api/document/{id}/sentences => DocumentSentences

Returns the sentences from a document

ParameterTypeDescription
idstringDocument id

[GET] /api/document/{id}/topics => TopicInfo[]

Returns a ranked list of topics from a document

ParameterTypeDescription
idstringDocument id

[DELETE] /api/document/{id} => bool

Deletes a document

ParameterTypeDescription
idstringDocument id

[POST] /api/document?title={documentTitle} => DocumentInfo

Creates a new editable document

ParameterTypeDescription
documentTitlestringDocument title(optional)

[PUT] /api/document/{id} => StatusMessage

Updates the information about a document

Message Body

Document information

ParameterTypeDescription
idstringDocument id

[POST] /api/document/{id}/flag => StatusMessage

Sets a flag on the document

ParameterTypeDescription
idstringDocument id

[DELETE] /api/document/{id}/flag => StatusMessage

Removes a flag on the document

ParameterTypeDescription
idstringDocument id

[POST] /api/document/{id}/tag?tag={tag} => StatusMessage

Adds a tag to a document

ParameterTypeDescription
idstringDocument id
tagstringTag to add

[DELETE] /api/document/{id}/tag?tag={tag} => StatusMessage

Removes a tag from a document

ParameterTypeDescription
idstringDocument id
tagstringTag to remove

Document Topics

[GET] /api/document/topic/search?q={query}&s={start}&c={count}&t={tags}&f={flagged} => PagedResponse of TopicInfo

Searches for topics within documents

ParameterTypeDescription
querystringSearch query
startunsigned integerStart offset(optional)
countunsigned integerTopic count to return(optional)
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

[GET] /api/document/topic/list?s={start}&c={count}&t={tags}&f={flagged} => PagedResponse of TopicInfo

Gets a list of topics from documents, ordered by frequency of occurrence

ParameterTypeDescription
startunsigned integerStart offset(optional)
countunsigned integerTopic count to return(optional)
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

[GET] /api/document/topic/sentence?q={topicQuery}&s={start}&c={count}&t={tags}&f={flagged} => TopicSentences

Returns the sentence that contain all topic ids

ParameterTypeDescription
topicQuerystringPipe delimited list of topic ids
startunsigned integerStart offset(optional)
countunsigned integerTopic count to return(optional)
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

[GET] /api/document/topic/all?sid={senseIndex}&t={tags}&f={flagged} => TopicInfo[]

Returns topics from indexed documents that are associated with the specified sense index

ParameterTypeDescription
senseIndexunsigned integerSense index to query
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

[GET] /api/document/topic/all?c={category}&t={tags}&f={flagged} => TopicInfo[]

Returns topics from indexed documents that are associated with the specified category

ParameterTypeDescription
categorystringDocument cateogory
tagsstringPipe separated tags to filter documents (only documents with ANY tag)(optional)
flaggedboolOptional flagged status filter on documents(optional)

Graphs

[POST] /api/graph?tid={tableId} => GraphInfo

Creates a new graph that contains the specified table

ParameterTypeDescription
tableIdstringTable id

[GET] /api/graph?s={start}&c={count} => PagedResponse of GraphInfo

Returns a page of graphs

ParameterTypeDescription
startunsigned integerStart offset(optional)
countunsigned integerCount of graphs to return(optional)

[DELETE] /api/graph/{id} => bool

Deletes a graph

ParameterTypeDescription
idstringGraph id

Page

[GET] /api/page/parse?url={urlToParse} => DocumentContent

ParameterTypeDescription
urlToParsestring-

Interfaces

AccountUsage

Counts associated with an account

interface AccountUsage {
	documentCount:                 number,                  // Document count
	documentSize:                  number,                  // Size in bytes of documnts
	dataTableCount:                number,                  // Data table count
	dataTableSize:                 number,                  // Size in bytes of data tables
	graphCount:                    number,                  // Number of graphs that have been created
	graphItemCount:                number,                  // Count of tables or models within graphs
	graphItemSize:                 number,                  // Size in bytes of models or tables within graphs
	apiUsage:                      number,                  // Count of API usage
	bandwidthUsage:                number,                  // Bandwidth usage
	topicCount:                    number,                  // Count of topics that have been associated with documents
}

AddDataTableResponse

Response from adding a data table

interface AddDataTableResponse extends StatusMessage {
	dataTable:                     DataTableInfo,           // Information about the new table
	graph:                         GraphInfo,               // 
}

AnalysedWord

Word with expanded topics and senses

interface AnalysedWord {
	text:                          string,                  // Word text
	lemma:                         string,                  // Base form of word (optional)
	partOfSpeech:                  PartOfSpeech,            // Word part of speech
	questionType?:                 QuestionType,            // The question classification for this word
	topic:                         TopicInfo[],             // Matching topics
	expandedTopic:                 TopicInfo[],             // Similiar topics
	sense:                         SenseIndex[],            // Possible senses
}

BernouliNaiveBayesModel

Bernouli naive bayes classification model

interface BernouliNaiveBayesModel {
	classifications:               NaiveBayesClassification[],// Classification data
	vocabulary:                    number[],                // The list of string indexes that were in the training set
}

ClassificationTransform

Classifiation transformation

interface ClassificationTransform {
	modelType:                     MachineLearningModelType,// Classification model
	tableSignature:                string,                  // Input data table signature
}

ColumnPropertyValue

A property of a data table column

interface ColumnPropertyValue {
	name:                          string,                  // Property name
	value:                         string,                  // Property value
}

DataTableColumn

A column in a data table

interface DataTableColumn {
	columnIndex:                   number,                  // Index of the column
	name:                          string,                  // The column name
	type:                          DataType,                // The column's data type
	property:                      ColumnPropertyValue[],   // Column meta data
	isClassificationTarget:        boolean,                 // True if this column is the classification target
	numDistinctValues:             number,                  // Number of distinct values found in this column
	xDimension?:                   number,                  // Size of the tensor/matrix/vector columns (optional)
	yDimension?:                   number,                  // Size of the tensor/matrix rows (optional)
	zDimension?:                   number,                  // Size of the tensor depth (optional)
}

DataTableColumnConversion

Information about a data table column conversion

interface DataTableColumnConversion {
	index:                         number,                  // Column index to convert
	newType:                       DataType,                // The data type to conver to
	replacement:                   string,                  // A replacement value to use if the conversion fails (optional)
	info:                          string,                  // Additional information to use during the conversion
}

DataTableData

Data from a table

interface DataTableData {
	rows:                          DataTableRow[],          // Array of rows
}

DataTableIndexList

Index lists are sparse vectors with entries of 1 if specified

interface DataTableIndexList {
	indices:                       number[],                // List of entries in the index list
}

DataTableInfo

Data table information

interface DataTableInfo {
	id:                            string,                  // Data table id
	numRows:                       number,                  // Total number of rows in the table
	numCols:                       number,                  // Total number of columns
	size:                          number,                  // Table size in bytes
	name:                          string,                  // Table name
	dateCreated:                   Date,                    // Date the table was created
	signature:                     string,                  // Table signature (for column equivalence comparison)
	columns:                       DataTableColumn[],       // Array of columns
	type:                          DataTableType,           // Type of data table
}

DataTableMatrix

A matrix contains a list of vectors as rows

interface DataTableMatrix {
	rows:                          DataTableVector[],       // The rows in the matrix
}

DataTableRow

A row in a data table

interface DataTableRow {
	index:                         number,                  // Row index
	data:                          string[],                // Array of table data
}

DataTableRowClassification

A row that has been classified

interface DataTableRowClassification extends DataTableRow {
	classification:                string,                  // The classification lable attached to the row
	isCorrect:                     boolean,                 // True if the classification was correct
}

DataTableTensor

Tensors are a list of matrices

interface DataTableTensor {
	slices:                        DataTableMatrix[],       // Depth slices in the tensor (each depth slice is a matrix)
}

DataTableVector

Vectors are indexed lists of numbers (dense)

interface DataTableVector {
	values:                        number[],                // The indexed list of numbers
}

DataTableWeightedIndex

Sparse index with weight

interface DataTableWeightedIndex {
	index:                         number,                  // The index of the value
	weight:                        number,                  // The weight at this index
}

DecisionTreeNodeModel

Decision tree model

interface DecisionTreeNodeModel {
	children:                      DecisionTreeNodeModel[], // The nodes children
	columnIndex:                   number,                  // The column index that is being split on
	matchLabel:                    string,                  // The value to match against this node
	split?:                        number,                  // The value to split on
	classification:                string,                  // Classification label
}

DocumentContent

Document content

interface DocumentContent {
	id:                            string,                  // Page id
	title:                         string,                  // Page tite
	description:                   string,                  // Page description
	content:                       Section[],               // Array of sections
}

DocumentInfo

Document information

interface DocumentInfo {
	id:                            string,                  // Document unique id
	dateCreated:                   Date,                    // Date created
	title:                         string,                  // Main document title
	description:                   string,                  // Short document description
	isFlagged:                     boolean,                 // True if the document is flagged
	tags:                          string[],                // List of tags (optional)
}

DocumentSentences

Document parse results

interface DocumentSentences {
	paragraphs:                    ParagraphSentences[],    // Array of paragraphs
}

DocumentTopicSentence

A matching sentence

interface DocumentTopicSentence {
	topics:                        TopicInfo[],             // Sentence topics
	text:                          string,                  // Sentence text
}

DocumentTopicSentences

A document with matching sentences

interface DocumentTopicSentences {
	id:                            string,                  // Unique document id
	title:                         string,                  // Document title
	type:                          string,                  // Document resource type
	sentences:                     DocumentTopicSentence[], // Array of sentences
	paragraphIds:                  number[],                // Matching paragraph ids
}

ExpandedSenseIndex

A sense index whose sense pointers have been expanded to include the sense indices they refer to

interface ExpandedSenseIndex extends SenseIndex {
	expandedPointers:              ExpandedSensePointer[],  // List of expanded sense pointers
}

ExpandedSensePointer

A sense pointer that has been expanded to include the sense index it points to

interface ExpandedSensePointer extends SenseIndex {
	type:                          PointerType,             // Pointer type
	source:                        number,                  // Source word index (0 for all words)
	target:                        number,                  // Target word index (0 for all words)
}

FeedForwardInfo

Feed forward node

interface FeedForwardInfo extends MachineLearningGraphComponent {
	activation:                    ActivationType,          // Activation type
	layerSize:                     number,                  // Count of neurons
}

FeedForwardLayer

Weights and bias of a feed forward layer

interface FeedForwardLayer {
	inputSize:                     number,                  // Input size
	outputSize:                    number,                  // Output size
	bias:                          DataTableVector,         // Layer bias
	weights:                       DataTableMatrix,         // Layer weights
}

GlossWord

A word within a sense index's definition

interface GlossWord {
	text:                          string,                  // Word text
	pos:                           PartOfSpeech,            // Part of speech
	semanticIndex?:                number,                  // (Optional) sense index id
	hasLeadingSpace:               boolean,                 // True if the word has a leading space
}

GraphInfo

Information about a bright wire studio graph

interface GraphInfo {
	id:                            string,                  // Unique graph id
	name:                          string,                  // Name of the graph
	dateCreated:                   Date,                    // Date the graph was created
}

JobInfo

Information about a lodged job

interface JobInfo {
	id:                            string,                  // Job unique id
	type:                          JobType,                 // Job type
	status:                        string,                  // Job completion status
	date:                          Date,                    // Job lodgement date
	hasCompleted:                  boolean,                 // True if the job has completed
	inputSize:                     number,                  // Size in characters of the job input
	outputSize:                    number,                  // Size in bytes of the job's output
	cost:                          number,                  // Cost in credits to execute the job
}

KNNInstance

K Nearest Neighbours instance to compare against

interface KNNInstance {
	data:                          DataTableVector,         // Data that will be compared against
	classification:                string,                  // Classification label
}

KNNModel

K Nearest Neighbours Model

interface KNNModel {
	instances:                     KNNInstance[],           // List of instances to compare against
}

LinearRegressionModel

Linear regression model

interface LinearRegressionModel {
	theta:                         DataTableVector,         // The model parameters
	error:                         number,                  // The error rate
}

LogisticRegressionModel

Logistic regression model

interface LogisticRegressionModel {
	theta:                         DataTableVector,         // Theta values that have been learnt
	classification:                string,                  // Classification label
}

MachineLearningGraph

A graph of nodes and wires

interface MachineLearningGraph {
	nodes:                         MachineLearningGraphNode[],// Array of nodes in the graph
	wires:                         MachineLearningGraphWire[],// Array of wires in the graph
}

MachineLearningGraphComponent

A node within a machine learning graph

interface MachineLearningGraphComponent {
	inputSize:                     number,                  // Node input size
	outputSize:                    number,                  // Node output size
}

MachineLearningGraphNode

A node in a machine learning graph

interface MachineLearningGraphNode {
	id:                            string,                  // Node unique id
	type:                          MachineLearningGraphNodeType,// Node type
	transformationType:            MachineLearningTransformationType,// Transformation type (optional)
	infoJson:                      string,                  // JSON that contains summary information about the node
}

MachineLearningGraphWire

Wires connect nodes (aka edges)

interface MachineLearningGraphWire {
	fromId:                        string,                  // The source node id
	toId:                          string,                  // The target node id
	inputChannel:                  number,                  // The channel on the target node to send the source node's output
}

MachineLearningModelInfo

Machine learning model information

interface MachineLearningModelInfo {
	id:                            string,                  // Unique id
	type:                          MachineLearningModelType,// Type of model
	infoJson:                      string,                  // JSON with summary information
	size:                          number,                  // Model size in bytes
	dateCreated:                   Date,                    // Date model was created
	inputSignature:                string,                  // Data table input signature
	outputSignature:               string,                  // Data table output signature
}

MarkovModelInfo

Information about a markov model

interface MarkovModelInfo {
	size:                          number,                  // Size of the prior states
	observations:                  MarkovModelObservation[],// List of observations
}

MarkovModelObservation

An observation within a markov model

interface MarkovModelObservation {
	data:                          string[],                // The list of prior to current states
	transitions:                   MarkovModelTransition[], // The list of possible transitions from this state
}

MarkovModelTransition

Probability of transitioning to a new state

interface MarkovModelTransition {
	nextState:                     string,                  // The next state
	probability:                   number,                  // The probability of this next state
}

MultinomialLogisticRegressionModel

A list of logistic regression models

interface MultinomialLogisticRegressionModel {
	models:                        LogisticRegressionModel[],// Each model corresponds to a single classification
}

MultinomialNaiveBayesModel

Multinomial naive bayes classification model

interface MultinomialNaiveBayesModel {
	classifications:               NaiveBayesClassification[],// Classification data
}

NaiveBayesCategory

A category within a naive bayes model

interface NaiveBayesCategory {
	name:                          string,                  // Category name
	probability:                   number,                  // Log of the category's probability
}

NaiveBayesClassification

A classification within a naive bayes model

interface NaiveBayesClassification {
	label:                         string,                  // The classification label
	prior:                         number,                  // The log of the prior probablilty for this classification
	missingProbability:            number,                  // The log of the missing probability
	index:                         NaiveBayesStringIndexProbability[],// The list of probabilities for each string index
	inverseMissingProbability:     number,                  // The log of the inverse missing probability
}

NaiveBayesClassification

A classification within a naive bayes model

interface NaiveBayesClassification {
	classification:                string,                  // The classification label
	prior:                         number,                  // Log of the prior probability
	columns:                       NaiveBayesColumn[],      // Columns to consider
}

NaiveBayesColumn

A column within a naive bayes model

interface NaiveBayesColumn {
	index:                         number,                  // Column index
	isCategorical:                 boolean,                 // True if this is a categorical column
	mean:                          number,                  // Column mean (if continuous)
	variance:                      number,                  // Column variance (if continuous)
	categories:                    NaiveBayesCategory[],    // List of possible catgories (if categorical)
}

NaiveBayesModel

Naive bayes model

interface NaiveBayesModel {
	classifications:               NaiveBayesClassification[],// List of classifications
}

NaiveBayesStringIndexProbability

The probabilities associated with a string index

interface NaiveBayesStringIndexProbability {
	stringIndex:                   number,                  // The string index
	conditionalProbability:        number,                  // The log of the conditional probability
	inverseProbability:            number,                  // The log of the inverse conditional probability
}

NormalisationModel

Data table normalisation model

interface NormalisationModel {
	type:                          DataTableNormalisationType,// Type of normalisation that was applied
	columns:                       NormalisationModelColumn[],// 
	vectorColumns:                 NormalisationModelVectorColumn[],// 
}

NormalisationModelColumn

A column within a normalisation model

interface NormalisationModelColumn {
	columnIndex:                   number,                  // The column index
	dataType:                      DataType,                // The type of data in the column
	subtract:                      number,                  // The value to subtract from the column
	divide:                        number,                  // The value to divide the column with (after subtraction)
}

NormalisationModelVectorColumn

A vector based column to normalise

interface NormalisationModelVectorColumn {
	columnIndex:                   number,                  // The column index
	columns:                       NormalisationModelColumn[],// The normalisation data within the vector (each index within the vector becomes a "column")
}

PagedResponse

A page of results

interface PagedResponse {
	total:                         number,                  // Total number of results
	offset:                        number,                  // Page offset
	data:                          T[],                     // Array of results
}

Paragraph

A paragraph of text

interface Paragraph {
	id:                            number,                  // Paragraph id
	spans:                         Span[],                  // Array of text spans
	isListItem:                    boolean,                 // True if the paragraph is a list item
	classification:                ParagraphClassification, // Paragraph classification
	isKey:                         boolean,                 // True if the paragraph ranks highly for importance on the page
}

ParagraphSentences

A paragraph

interface ParagraphSentences {
	index:                         number,                  // Paragraph id
	sentences:                     Sentence[],              // Array of sentences
}

ParagraphTopic

A topic within the content

interface ParagraphTopic {
	sentenceOffset:                number,                  // Offset of the topic
	topic:                         TopicInfo,               // Topic information
}

ParseBlock

A block of text within a parse job

interface ParseBlock {
	id:                            string,                  // 
	text:                          string,                  // 
}

ParseBlockResult

The results of parsing a block from a parse job

interface ParseBlockResult {
	id:                            string,                  // 
	text:                          string,                  // 
	sentenceTokens:                SimpleToken[][],         // 
}

ParseJob

A parse job contains blocks of text to process

interface ParseJob {
	blocks:                        ParseBlock[],            // 
	findPartsOfSpeech:             boolean,                 // 
	findTopics:                    boolean,                 // 
	findSemantics:                 boolean,                 // 
	analyseSentiment:              boolean,                 // 
	findCompositeWords:            boolean,                 // 
}

ParseJobResults

Re

interface ParseJobResults {
}

QueryWord

Search query word

interface QueryWord {
	ordinal:                       number,                  // Word group id
	words:                         string[],                // Array of related strings
}

QuestionAnalysisResults

Question analysis results

interface QuestionAnalysisResults {
	words:                         AnalysedWord[],          // Array of analysed words
}

RandomForestModel

Random forest model

interface RandomForestModel {
	forest:                        DecisionTreeNodeModel[], // List of trees in the forest
}

Related

Related content paragraphs

interface Related {
	documents:                     RelatedDocument[],       // Array of related documents
	source:                        SourceDocument[],        // Array of source documents
	offset:                        number,                  // Page offset
	total:                         number,                  // Total number of results
}

RelatedDocument

A related document

interface RelatedDocument extends DocumentInfo {
	score:                         number,                  // Relatedness score
	paragraphs:                    RelatedParagraph[],      // Array of related paragraphs within the document
}

RelatedParagraph

A related paragraph

interface RelatedParagraph {
	id:                            number,                  // Paragraph id
	text:                          string,                  // Paragraph text
	score:                         number,                  // Relatedness score
	topics:                        ParagraphTopic[],        // Array of topics
}

Section

A section of text

interface Section {
	title:                         Paragraph,               // Optional title
	content:                       Paragraph[],             // Array of paragraphs
	classification:                SectionClassification,   // Section classification
}

SemanticResult

Expanded topic result

interface SemanticResult {
	topic:                         TopicInfo,               // Topic information
	senseIndex:                    SenseIndex,              // Sense index that matches a group of topics
	category:                      string,                  // Topic cateogry
}

SenseIndex

WordNet sense index

interface SenseIndex {
	partOfSpeech:                  WordnetPartOfSpeech,     // Part of speech
	name:                          string[],                // List of words in the sense index's name
	classifications:               string[],                // List of words that specify the sense index domain (optional)
	definitionWords:               GlossWord[],             // List of words in the definition
	examples:                      string[],                // List of example sentences (optional)
	pointers:                      SensePointer[],          // List of pointers to related sense indices
	verbFrames:                    VerbFrame[],             // List of verb frames (optional)
	uniqueId:                      string,                  // Unique string id
	id:                            number,                  // Numeric id
	hasTopics:                     boolean,                 // Indicates if the sense index has topics associated with it
}

SensePointer

Pointer to a sense index

interface SensePointer {
	id:                            number,                  // Sense index id
	type:                          PointerType,             // Type of pointer
	source:                        number,                  // Source word index (0 for all words)
	target:                        number,                  // Target word index (0 for all words)
}

Sentence

A sentence

interface Sentence {
	text:                          string,                  // Sentence text
	indices:                       SentenceIndex[],         // Array of token annotations
	topics:                        TopicIndex[],            // Array of topics in sentence
}

Sentence

Parsed sentence

interface Sentence {
	words:                         Word[],                  // Array of words
}

SentenceIndex

Token annotation

interface SentenceIndex {
	type:                          TokenType,               // Token type
	partOfSpeech:                  PartOfSpeech,            // Part of speech
	offset:                        number,                  // Offset in the text
}

SimpleToken

Simple tokenisation token

interface SimpleToken {
	type:                          TokenType,               // Token type
	text:                          string,                  // Token text
	lemma:                         string,                  // Token lemma (optional)
}

SourceDocument

A document that contains the source text that was compared against

interface SourceDocument {
	id:                            string,                  // Unique document id
	type:                          string,                  // Type of document
	paragraphs:                    RelatedParagraph[],      // Array of source paragraphs
}

Span

A span of text

interface Span {
	type:                          SpanType,                // Span type
	text:                          string,                  // Text content
	hyperlink:                     string,                  // Hyperlink
	imageSrc:                      string,                  // Image source
	isBold:                        boolean,                 // True if the text is bold
	isItalic:                      boolean,                 // True if the text is italic
	isUnderline:                   boolean,                 // True if the text is underline
}

StatusMessage

Status message

interface StatusMessage {
	message:                       string,                  // Message (optional)
	isError:                       boolean,                 // True if the call failed
}

StructuredTypeInfo

Information about a structured type

interface StructuredTypeInfo {
	id:                            string,                  // Unique id
	isFlagged:                     boolean,                 // True if the type has been flagged
	title:                         string,                  // Type title
	description:                   string,                  // Type description
	typeData:                      string,                  // JSON of type definition
}

SubscriptionInfo

Subscription information

interface SubscriptionInfo {
	name:                          string,                  // Subscription name
	startDate:                     Date,                    // Date subscription started
	endDate:                       Date,                    // Date subscription ends
}

TextAnalysisResults

Results from text analysis

interface TextAnalysisResults {
	id:                            string,                  // A temporary id that refers to this text analysis
	tokens:                        Token[],                 // The array of parsed tokens
	tokenAnalysis:                 TokenAnalysis[],         // Flat list of tokens
}

Token

A recursive token within a parse tree

interface Token {
	type:                          TokenType,               // Token type
	partOfSpeech:                  PartOfSpeech,            // Token part of speech
	text:                          string,                  // Token text
	lemma:                         string,                  // Base form of word (optional)
	offset:                        number,                  // Equivalent to an ordered id - the offset of the token within the text
	isCapitalised:                 boolean,                 // True if the token is capitalised
	isPlural:                      boolean,                 // True if the token is a plural noun
	isPassive:                     boolean,                 // True if the token is a passive verb
	isQuestion:                    boolean,                 // True if the token is a question
	topicId:                       number[],                // List of possible topic ids associated with the token (if any)
	children:                      Token[],                 // List of the token's children (optional)
	senseIndex:                    number[],                // List of possible WordNet sense indices (if any)
	referent:                      number[],                // List of referents, indexed by token offset (optional)
}

TokenAnalysis

Represents a single token of analysis results

interface TokenAnalysis {
	partOfSpeech:                  PartOfSpeech,            // Token part of speech
	text:                          string,                  // Token text
	lemma:                         string,                  // Token lemma
	tokenTypes:                    TokenType[],             // Array of token types
	senseIndices:                  number[],                // Array of possible sense indices
	topicIds:                      number[],                // Array of possible topic ids
	topics:                        TopicInfo[],             // Possible topic connections
}

TopicIndex

Index of topic instance

interface TopicIndex {
	topic:                         TopicInfo,               // Topic information
	offset:                        number,                  // Offset in the text
}

TopicInfo

Topic information

interface TopicInfo {
	topicId:                       number,                  // Topic id
	title:                         string,                  // Name of the topic
	sense:                         number[],                // Related sense indices
	category:                      string[],                // List of the topic's categories
}

TopicSentences

Sentences matching a topic query

interface TopicSentences {
	query:                         string,                  // The query text
	topics:                        TopicInfo[],             // Array of topics from query
	relatedTopics:                 TopicInfo[],             // Array of related topics
	documents:                     DocumentTopicSentences[],// Array of matching documents
	total:                         number,                  // Total number of results
	offset:                        number,                  // Request page offset
}

TrainingProgressInfo

Training progress information after each epoch

interface TrainingProgressInfo {
	testError:                     number,                  // Error against the test data
	trainingError:                 number,                  // Error against the training data
	isPercentage:                  boolean,                 // True if test and training errors represent a percentage value (higher is better)
	hasImproved:                   boolean,                 // True if the results improved since the last epoch
	message:                       string,                  // Text summary message
}

TransformationBagTable

Data table bag transformation

interface TransformationBagTable {
	sampleCount:                   number,                  // Count of samples
}

TransformationCluster

A cluster transformation

interface TransformationCluster {
	k:                             number,                  // Number of clusters
}

TransformationClusterKMeans

K means cluster

interface TransformationClusterKMeans extends TransformationCluster {
	maxIterations:                 number,                  // Max number of iterations the algorithm was run
}

TransformationExtractClassification

Extract classification transformation

interface TransformationExtractClassification {
	classification:                string,                  // Classification that was extracted
}

TransformationNoArguments

A transformation that accepted no arguments

interface TransformationNoArguments {
}

TransformationReduceTable

Data table reduction transformation (SVD)

interface TransformationReduceTable {
	toDimensions:                  number,                  // Number of dimensions that were produced
}

TransformationSliceTableColumns

Data table columns slice transformation

interface TransformationSliceTableColumns {
	sourceTableColumnIndices:      number[],                // Columns that were sliced
}

TransformationSliceTableRows

Data table rows slice

interface TransformationSliceTableRows {
	start:                         number,                  // First row index that was included in the slice
	end:                           number,                  // Last row index that was included in the slice
}

TransformationSplitTable

Data table split

interface TransformationSplitTable {
	trainingPercentage:            number,                  // Percent of the data that was included in the training split
}

TransformationSummariseTable

Summarise table

interface TransformationSummariseTable {
	newRows:                       number,                  // New rows in the summarised table
}

TransformationTableNormalise

Table normalisation

interface TransformationTableNormalise {
	type:                          DataTableNormalisationType,// Type of normalisation that was applied
}

TransformationTrain

Train machine learning graph

interface TransformationTrain extends MachineLearningGraphComponent {
	trainingTableId:               string,                  // Training table id
	testTableId:                   string,                  // Test table id
	iterations:                    number,                  // Iterations last trained for
	learningRate:                  number,                  // Learning rate
	batchSize:                     number,                  // Batch size
	errorMetric:                   ErrorMetric,             // Error metric
	gradientDescent:               GradientDescentType,     // Gradient descent optimisation
	l2Regularisation?:             number,                  // L2 Regularisation
	weightInitialisation:          WeightInitialisationType,// Weight initialisation type
}

TransformationTrainDecisionTree

Decision tree trained

interface TransformationTrainDecisionTree extends ClassificationTransform {
}

TransformationTrainLogisticRegression

Logistic regression trained

interface TransformationTrainLogisticRegression extends ClassificationTransform {
	iterations:                    number,                  // Iterations gradient descent was run
	trainingRate:                  number,                  // Training rate
	lambda:                        number,                  // Regularisation lambda
}

TransformationTrainMarkovModel

Markov model trained

interface TransformationTrainMarkovModel {
	size:                          number,                  // Number of prior states in the model
}

TransformationTrainRandomForest

Random forest trained

interface TransformationTrainRandomForest extends ClassificationTransform {
	numberOfTrees:                 number,                  // Number of trees in the forest
}

VectorisationModel

interface VectorisationModel {
	columns:                       VectorisationModelColumn[],// The columns in the table
	inputSize:                     number,                  // The size of each input vector that will be created
	outputSize:                    number,                  // The size of each output vector that will be created
	hasTarget:                     boolean,                 // True if the vectoriser has a classification target column
	isTargetContinuous:            boolean,                 // True if the classification target column is continuous
	targetColumnIndex?:            number,                  // The column index of the classifiation target column
	isTargetBinary:                boolean,                 // True if the classification target column has one of two possible values
}

VectorisationModelCategoricalIndex

A categorical column value

interface VectorisationModelCategoricalIndex {
	category:                      string,                  // The classification label
	index:                         number,                  // The label's index
}

VectorisationModelColumn

Information about a column within a vectorisation model

interface VectorisationModelColumn {
	columnIndex:                   number,                  // The column index
	name:                          string,                  // Column name
	isTargetColumn:                boolean,                 // True if the column is the classification target
	isContinuous:                  boolean,                 // True if the column has a continuous value
	size:                          number,                  // The number of slots this column will fill in the output vector
	values:                        VectorisationModelCategoricalIndex[],// An array of categorial values
	isBinary:                      boolean,                 // True if the column has one of two possible values
}

VerbFrame

A verb frame

interface VerbFrame {
	index:                         number,                  // Verb frame index. See https://wordnet.princeton.edu/man/wninput.5WN.html#toc4
	wordIndex:                     number,                  // Word index that the frame refers to (0 for all words)
}

Word

A parsed word

interface Word {
	text:                          string,                  // Word text
	lemma:                         string,                  // Base form of word (optional)
	partOfSpeech:                  PartOfSpeech,            // Word part of speech
	sentimentStrength?:            number,                  // The strength of sentiment - from 0 (low) to 1 (high)
	sentimentPolarity?:            number,                  // The type of sentiment expressed - from 0 (negative) to 1 (positive)
	questionType?:                 QuestionType,            // The question classification for this word
	hasLeadingSpace:               boolean,                 // True if the word has a leading space
}

WordEmbeddingResponse

Word embedding query response

interface WordEmbeddingResponse {
	query:                         string,                  // Query text
	results:                       WordEmbeddingResult[],   // Word results
	words:                         WordEmbeddingWord[],     // Parsed words from the query
}

WordEmbeddingResult

An associated word and score

interface WordEmbeddingResult {
	word:                          string,                  // Word text
	score:                         number,                  // Word score
}

WordEmbeddingWord

Parsed word from the query

interface WordEmbeddingWord {
	text:                          string,                  // Word query
	isPositive:                    boolean,                 // True for positive, false for negative
}

WordnetSearchResults

WordNet search results

interface WordnetSearchResults {
	suggestions:                   string[],                // List of suggested words if nothing was found
	senses:                        SenseIndex[],            // List of matching sense indices
}

Enums

ActivationType

Neural network layer activation type


const enum ActivationType {
		none                           = 0,                       // No activation
		sigmoid                        = 1,                       // Sigmoid activation
		tanh                           = 2,                       // Tanh activation
		softmax                        = 3,                       // Softmax activation
		relu                           = 4,                       // RELU activation
		leakyRelu                      = 5,                       // Leaky RELU activation
	}

BlockType

Type of document block


const enum BlockType {
		empty                          = 0,                       // None
		richText                       = 1,                       // Rich text
		image                          = 2,                       // Image
		code                           = 3,                       // Source code
		structured                     = 4,                       // Structured data
		static                         = 5,                       // Static html from a page
		group                          = 6,                       // Group of blocks
		table                          = 7,                       // Tabular data
		parsedDocumentSection          = 8,                       // A section of a parsed document
	}

DataTableNormalisationType

Data normalisation options


const enum DataTableNormalisationType {
		standard                       = 0,                       // Normalises based on standard deviation
		manhattan                      = 1,                       // Normalise from manhattan distance
		euclidean                      = 2,                       // Normalise from eucildean distance
		featureScale                   = 3,                       // Normalise based on min and max values
	}

DataTableType

Data table meta data


const enum DataTableType {
		normal                         = 0,                       // Normal data table
		trainingData                   = 1,                       // Training data from split
		testData                       = 2,                       // Test data from split
		clusterResults                 = 3,                       // Results of clustering another table
		reducedToTwo                   = 4,                       // Another table's data reduced to two dimensions
		reducedToThree                 = 5,                       // Another table's data reduced to three dimensions
		classificationResults          = 6,                       // Created from classifying another table
		stringTable                    = 7,                       // String tables are strings associated with indices
	}

DataType

Table column data type


const enum DataType {
		null                           = 0,                       // null
		boolean                        = 1,                       // Boolean values
		byte                           = 2,                       // Byte values
		int                            = 3,                       // Integer values
		long                           = 4,                       // Long integer values
		float                          = 5,                       // Float values
		double                         = 6,                       // Double values
		string                         = 7,                       // String values
		date                           = 8,                       // Date values
		indexList                      = 9,                       // List of indices
		weightedIndexList              = 10,                      // Weighted list of indices
		vector                         = 11,                      // Vector of floats
		matrix                         = 12,                      // Matrix of floats
		tensor                         = 13,                      // 3D tensor of floats
	}

ErrorMetric

Graph error metric


const enum ErrorMetric {
		crossEntropy                   = 0,                       // 
		quadratic                      = 1,                       // 
		binaryClassification           = 2,                       // 
		oneHotEncoding                 = 3,                       // 
	}

GradientDescentType

Gradient descent optimisation


const enum GradientDescentType {
		simple                         = 0,                       // 
		adam                           = 1,                       // 
		rmsProp                        = 2,                       // 
		adaGrad                        = 3,                       // 
		momentum                       = 4,                       // 
		nesterov                       = 5,                       // 
	}

JobType

The type of job


const enum JobType {
		unknown                        = 0,                       // Unknown job type
		tokenise                       = 1,                       // Tokenisation
		wordEmbedding                  = 2,                       // Word embedding
		partsOfSpeech                  = 3,                       // Parts of speech
		syntaxAnalysis                 = 4,                       // Syntax analysis
		sentimentAnalysis              = 5,                       // Sentiment analysis
		topicDetection                 = 6,                       // Topic detection
		semanticAnalysis               = 7,                       // Semantic analysis
		questionAnalysis               = 8,                       // Question analysis
		parse                          = 9,                       // Parse
	}

MachineLearningGraphNodeType

Type of node in a machine learning graph


const enum MachineLearningGraphNodeType {
		data                           = 0,                       // Data table
		transformation                 = 1,                       // A node that transforms existing data
		model                          = 2,                       // A model that can produce new data
	}

MachineLearningModelType

Tyoe of machine learning model


const enum MachineLearningModelType {
		unknown                        = 0,                       // Unknown
		naiveBayes                     = 1,                       // Naive bayes
		decisionTree                   = 2,                       // Decision tree
		randomForest                   = 3,                       // Random forest
		logisticRegression             = 4,                       // Logistic regression
		kNearestNeighbours             = 5,                       // K nearest neighbours
		input                          = 6,                       // An input node within a graph
		feedForward                    = 7,                       // Feed forward layer
		backpropagate                  = 8,                       // Backpropagate node
		constrain                      = 9,                       // Input constraint
		dropConnectRegularisation      = 10,                      // Drop connect regularisation
		dropOutRegularisation          = 11,                      // Drop out regularisation
		normalisation                  = 12,                      // Normalisation model
		vectorisation                  = 13,                      // Vectorisation model
		markov                         = 14,                      // Markov model
		multinomialNaiveBayes          = 15,                      // Multinomial naive bayes
		bernouliNaiveBayes             = 16,                      // Bernouli naive bayes
		linearRegression               = 17,                      // Linear regression
	}

MachineLearningTransformationType

Transformation type within a machine learning graph


const enum MachineLearningTransformationType {
		unknown                        = 0,                       // No
		train                          = 1,                       // 
		classify                       = 2,                       // 
		splitTable                     = 3,                       // 
		normaliseTable                 = 4,                       // 
		vectoriseTable                 = 5,                       // 
		reduceTable                    = 6,                       // 
		summariseTable                 = 7,                       // 
		extractClassificationFromTable = 8,                       // 
		joinTable                      = 9,                       // 
		zipTable                       = 10,                      // 
		sliceRows                      = 11,                      // 
		sliceColumns                   = 12,                      // 
		bagTable                       = 13,                      // 
		shuffleTable                   = 14,                      // 
		kMeansCluster                  = 15,                      // 
		hierarchicalCluster            = 16,                      // 
		output                         = 17,                      // 
		convert                        = 18,                      // 
		reverseNormalise               = 19,                      // 
		reverseVectorise               = 20,                      // 
	}

ParagraphClassification

Paragraph classification


const enum ParagraphClassification {
		textBlock                      = 0,                       // Block of text
		headingLike                    = 1,                       // Short text that resembles a heading
		link                           = 2,                       // A hyperlink
	}

PartOfSpeech

Part of speech tag


const enum PartOfSpeech {
		unknown                        = 0,                       // Not known
		word                           = 1,                       // A word
		punctuation                    = 2,                       // A punctuation character
		number                         = 3,                       // A number
		name                           = 4,                       // A given name
		interjection                   = 5,                       // Uh, huh etc
		symbol                         = 6,                       // A symbol
		article                        = 7,                       // An article (the, a, etc)
		conjunction                    = 8,                       // A conjunction(and, or, etc)
		preposition                    = 9,                       // A preposition (for, to, etc)
		pronoun                        = 10,                      // A pronoun (he, she, etc)
		noun                           = 11,                      // A noun
		verb                           = 12,                      // A verb
		adjective                      = 13,                      // An adjective
		adverb                         = 14,                      // An adverb
		possessiveNoun                 = 15,                      // A possessive noun (the dog's, a rabbit's, etc)
		possessivePronoun              = 16,                      // A posssessive pronoun (her, his, etc)
		possessiveName                 = 17,                      // A possessive name (John's, Julia's, etc)
		possessiveMarker               = 18,                      // A possessive marker (')
		max                            = 19,                      // Maximum value
	}

PointerType

WordNet sense pointer type


const enum PointerType {
		unknown                        = 0,                       // Not known
		antonym                        = 1,                       // Antonym
		hypernym                       = 2,                       // A more generic term
		instanceHypernym               = 3,                       // A specific instance of a more generic term
		memberHolonym                  = 4,                       // Holonym ("a part of") by member
		substanceHolonym               = 5,                       // Holonym ("a part of") by substance
		partHolonym                    = 6,                       // Holonym ("a part of")
		memberMeronym                  = 7,                       // Meronym ("is a part of") by member
		substanceMeronym               = 8,                       // Meronym ("is a part of") by substance
		partMeronym                    = 9,                       // Meronym ("is a part of")
		attribute                      = 10,                      // A noun for which adjectives express values. The noun weight is an attribute, for which the adjectives light and heavy express values.
		derivationallyRelatedForm      = 11,                      // Terms in different syntactic categories that have the same root form and are semantically related.
		domainOfSynsetCategory         = 12,                      // Related by category
		domainOfSynsetRegion           = 13,                      // Related by region
		domainOfSynsetUsage            = 14,                      // Related by usage
		memberOfDomainCategory         = 15,                      // Related by category
		memberOfDomainRegion           = 16,                      // Related by region
		memberOfDomainUsage            = 17,                      // Related by usage
		entailment                     = 18,                      // A verb X entails Y if X cannot be done unless Y is, or has been, done.
		cause                          = 19,                      // Verb causation
		alsoSee                        = 20,                      // Also see
		verbGroup                      = 21,                      // Verb group
		similiarTo                     = 22,                      // Similiar to
		participleOfVerb               = 23,                      // Participle Of Verb
		relatedTo                      = 24,                      // Hyponym - a "type of" relationship
		instanceRelatedTo              = 25,                      // Hyponym ("type of") relationship based on a specific instance
		derivedFromAdjective           = 26,                      // Derived from adjective
		pertainym                      = 27,                      // A relational adjective. Adjectives that are pertainyms are usually defined by such phrases as "of or pertaining to" and do not have antonyms. A pertainym can point to a noun or another pertainym.
		max                            = 28,                      // Maximum index
	}

QuestionType

Question type


const enum QuestionType {
		abbreviation                   = 0,                       // abbreviation
		abbreviationExpression         = 1,                       // expression abbreviated
		entityAnimal                   = 2,                       // animals
		entityBody                     = 3,                       // organs of body
		entityColour                   = 4,                       // colors
		entityCreative                 = 5,                       // inventions, books and other creative pieces
		entityCurrency                 = 6,                       // currency names
		entityDisease                  = 7,                       // diseases and medicine
		entityEvent                    = 8,                       // events
		entityFood                     = 9,                       // food
		entityInstrument               = 10,                      // musical instrument
		entityLanguage                 = 11,                      // languages
		entityLetter                   = 12,                      // letters like a-z
		entityOther                    = 13,                      // other entities
		entityPlant                    = 14,                      // plants
		entityProduct                  = 15,                      // products
		entityReligion                 = 16,                      // religions
		entitySport                    = 17,                      // sports
		entitySubstance                = 18,                      // elements and substances
		entitySymbol                   = 19,                      // symbols and signs
		entityTechnique                = 20,                      // techniques and methods
		entityTerm                     = 21,                      // equivalent terms
		entityVehichle                 = 22,                      // vehicles
		entityWord                     = 23,                      // words with a special property
		descriptionDefinition          = 24,                      // definition of something
		description                    = 25,                      // description of something
		descriptionManner              = 26,                      // manner of an action
		descriptionReason              = 27,                      // reasons
		humanGroup                     = 28,                      // a group or organization of persons
		humanIndividual                = 29,                      // an individual
		humanTitle                     = 30,                      // title of a person
		humanDescription               = 31,                      // description of a person
		locationCity                   = 32,                      // cities
		locationCountry                = 33,                      // countries
		locationMountiain              = 34,                      // mountains
		locationOther                  = 35,                      // other locations
		locationState                  = 36,                      // states
		numericCode                    = 37,                      // postcodes or other codes
		numericCount                   = 38,                      // number of something
		numericDate                    = 39,                      // dates
		numericDistance                = 40,                      // linear measures
		numericMoney                   = 41,                      // prices
		numericOrdinal                 = 42,                      // ranks
		numericOther                   = 43,                      // other numbers
		numericPeriod                  = 44,                      // the lasting time of something
		numericPercent                 = 45,                      // percent/fractions
		numericSpeed                   = 46,                      // speed
		numericTemperature             = 47,                      // temperature
		numericVolumeSize              = 48,                      // size, area and volume
		numericWeight                  = 49,                      // weight
		max                            = 50,                      // Max value
	}

SectionClassification

Section classification


const enum SectionClassification {
		menuList                       = 0,                       // A list of hyperlinks
		text                           = 1,                       // Text
		tableRow                       = 2,                       // A row in a table
	}

SpanType

Span type


const enum SpanType {
		text                           = 0,                       // Plain text
		hyperlink                      = 1,                       // Hyperlink
		image                          = 2,                       // Image
	}

TokenDescriptor

Token descriptor


const enum TokenDescriptor {
		unknown                        = 0,                       // Unknown
		word                           = 1,                       // Word
		capitalisedWord                = 2,                       // Capitalised word
		abbreviation                   = 3,                       // Acronym
		comma                          = 4,                       // ,
		quote                          = 5,                       // "
		colon                          = 6,                       // :
		semicolon                      = 7,                       // ;
		openParenthesis                = 8,                       // (
		closeParenthesis               = 9,                       // )
		dash                           = 10,                      // -
		punctuation                    = 11,                      // Any other punctuation character
		endOfSentenceMarker            = 12,                      // ! . ?
		adverb                         = 13,                      // Adverb
		adjective                      = 14,                      // Adjective
		article                        = 15,                      // Definite article
		conjunction                    = 16,                      // Conjunction
		interjection                   = 17,                      // Uh, like...
		preposition                    = 18,                      // Preposition
		pronoun                        = 19,                      // Pronoun
		possessivePronoun              = 20,                      // Possessive pronoun
		name                           = 21,                      // Person's name
		noun                           = 22,                      // Name
		pluralNoun                     = 23,                      // Plural noun
		verbContinuous                 = 24,                      // Continuous verb
		verbPast                       = 25,                      // Past tense verb
		verbPastParticiple             = 26,                      // Past participle verb
		verbPastSimple                 = 27,                      // Simple past tense verb
		verbPresent                    = 28,                      // Present tense verb
		verbInfinitive                 = 29,                      // Infinitive tense verb
		number                         = 30,                      // A number
		possessiveMarker               = 31,                      // A marker that indicates possession
		not                            = 32,                      // 
		be                             = 33,                      // 
		am                             = 34,                      // 
		is                             = 35,                      // 
		are                            = 36,                      // 
		was                            = 37,                      // 
		were                           = 38,                      // 
		been                           = 39,                      // 
		being                          = 40,                      // 
		have                           = 41,                      // 
		had                            = 42,                      // 
		has                            = 43,                      // 
		do                             = 44,                      // 
		does                           = 45,                      // 
		did                            = 46,                      // 
		going                          = 47,                      // 
		used                           = 48,                      // 
		a                              = 49,                      // 
		abaft                          = 50,                      // 
		aboard                         = 51,                      // 
		about                          = 52,                      // 
		above                          = 53,                      // 
		across                         = 54,                      // 
		after                          = 55,                      // 
		against                        = 56,                      // 
		ago                            = 57,                      // 
		albeit                         = 58,                      // 
		all                            = 59,                      // 
		along                          = 60,                      // 
		alongside                      = 61,                      // 
		also                           = 62,                      // 
		although                       = 63,                      // 
		amid                           = 64,                      // 
		amidst                         = 65,                      // 
		among                          = 66,                      // 
		amongst                        = 67,                      // 
		an                             = 68,                      // 
		and                            = 69,                      // 
		another                        = 70,                      // 
		anti                           = 71,                      // 
		any                            = 72,                      // 
		anybody                        = 73,                      // 
		anyone                         = 74,                      // 
		anything                       = 75,                      // 
		around                         = 76,                      // 
		as                             = 77,                      // 
		astride                        = 78,                      // 
		at                             = 79,                      // 
		atop                           = 80,                      // 
		because                        = 81,                      // 
		before                         = 82,                      // 
		behind                         = 83,                      // 
		below                          = 84,                      // 
		beneath                        = 85,                      // 
		beside                         = 86,                      // 
		besides                        = 87,                      // 
		between                        = 88,                      // 
		beyond                         = 89,                      // 
		both                           = 90,                      // 
		but                            = 91,                      // 
		by                             = 92,                      // 
		can                            = 93,                      // 
		circa                          = 94,                      // 
		could                          = 95,                      // 
		de                             = 96,                      // 
		despite                        = 97,                      // 
		down                           = 98,                      // 
		during                         = 99,                      // 
		each                           = 100,                     // 
		either                         = 101,                     // 
		et                             = 102,                     // 
		every                          = 103,                     // 
		everybody                      = 104,                     // 
		everybodys                     = 105,                     // 
		everyone                       = 106,                     // 
		everything                     = 107,                     // 
		except                         = 108,                     // 
		for                            = 109,                     // 
		forth                          = 110,                     // 
		from                           = 111,                     // 
		half                           = 112,                     // 
		he                             = 113,                     // 
		her                            = 114,                     // 
		hers                           = 115,                     // 
		herself                        = 116,                     // 
		him                            = 117,                     // 
		himself                        = 118,                     // 
		his                            = 119,                     // 
		how                            = 120,                     // 
		i                              = 121,                     // 
		if                             = 122,                     // 
		in                             = 123,                     // 
		inside                         = 124,                     // 
		into                           = 125,                     // 
		it                             = 126,                     // 
		its                            = 127,                     // 
		itself                         = 128,                     // 
		least                          = 129,                     // 
		lest                           = 130,                     // 
		like                           = 131,                     // 
		many                           = 132,                     // 
		may                            = 133,                     // 
		me                             = 134,                     // 
		might                          = 135,                     // 
		mine                           = 136,                     // 
		minus                          = 137,                     // 
		most                           = 138,                     // 
		must                           = 139,                     // 
		my                             = 140,                     // 
		myself                         = 141,                     // 
		near                           = 142,                     // 
		nearest                        = 143,                     // 
		neither                        = 144,                     // 
		no                             = 145,                     // 
		nobody                         = 146,                     // 
		none                           = 147,                     // 
		nor                            = 148,                     // 
		nothing                        = 149,                     // 
		notwithstanding                = 150,                     // 
		of                             = 151,                     // 
		off                            = 152,                     // 
		on                             = 153,                     // 
		onboard                        = 154,                     // 
		once                           = 155,                     // 
		one                            = 156,                     // 
		ones                           = 157,                     // 
		oneself                        = 158,                     // 
		onto                           = 159,                     // 
		opposite                       = 160,                     // 
		or                             = 161,                     // 
		other                          = 162,                     // 
		others                         = 163,                     // 
		our                            = 164,                     // 
		ours                           = 165,                     // 
		ourselves                      = 166,                     // 
		out                            = 167,                     // 
		outside                        = 168,                     // 
		over                           = 169,                     // 
		own                            = 170,                     // 
		past                           = 171,                     // 
		per                            = 172,                     // 
		plus                           = 173,                     // 
		post                           = 174,                     // 
		pro                            = 175,                     // 
		pursuant                       = 176,                     // 
		rather                         = 177,                     // 
		round                          = 178,                     // 
		same                           = 179,                     // 
		sans                           = 180,                     // 
		shall                          = 181,                     // 
		she                            = 182,                     // 
		should                         = 183,                     // 
		since                          = 184,                     // 
		so                             = 185,                     // 
		some                           = 186,                     // 
		somebody                       = 187,                     // 
		someone                        = 188,                     // 
		something                      = 189,                     // 
		somewhat                       = 190,                     // 
		such                           = 191,                     // 
		than                           = 192,                     // 
		that                           = 193,                     // 
		the                            = 194,                     // 
		their                          = 195,                     // 
		theirs                         = 196,                     // 
		theirself                      = 197,                     // 
		them                           = 198,                     // 
		themselves                     = 199,                     // 
		then                           = 200,                     // 
		there                          = 201,                     // 
		these                          = 202,                     // 
		they                           = 203,                     // 
		this                           = 204,                     // 
		those                          = 205,                     // 
		thou                           = 206,                     // 
		though                         = 207,                     // 
		through                        = 208,                     // 
		throughout                     = 209,                     // 
		thy                            = 210,                     // 
		thyself                        = 211,                     // 
		till                           = 212,                     // 
		times                          = 213,                     // 
		to                             = 214,                     // 
		toward                         = 215,                     // 
		towards                        = 216,                     // 
		under                          = 217,                     // 
		underneath                     = 218,                     // 
		undersurface                   = 219,                     // 
		unless                         = 220,                     // 
		unlike                         = 221,                     // 
		until                          = 222,                     // 
		unto                           = 223,                     // 
		up                             = 224,                     // 
		upon                           = 225,                     // 
		us                             = 226,                     // 
		versus                         = 227,                     // 
		via                            = 228,                     // 
		we                             = 229,                     // 
		what                           = 230,                     // 
		whatever                       = 231,                     // 
		whatsoever                     = 232,                     // 
		when                           = 233,                     // 
		whenever                       = 234,                     // 
		where                          = 235,                     // 
		whereas                        = 236,                     // 
		whereby                        = 237,                     // 
		wherein                        = 238,                     // 
		whereupon                      = 239,                     // 
		whether                        = 240,                     // 
		which                          = 241,                     // 
		while                          = 242,                     // 
		who                            = 243,                     // 
		whoever                        = 244,                     // 
		whom                           = 245,                     // 
		whomever                       = 246,                     // 
		whose                          = 247,                     // 
		whosoever                      = 248,                     // 
		why                            = 249,                     // 
		will                           = 250,                     // 
		with                           = 251,                     // 
		within                         = 252,                     // 
		without                        = 253,                     // 
		worth                          = 254,                     // 
		would                          = 255,                     // 
		ye                             = 256,                     // 
		yet                            = 257,                     // 
		you                            = 258,                     // 
		your                           = 259,                     // 
		yours                          = 260,                     // 
		yourself                       = 261,                     // 
		max                            = 262,                     // 
	}

TokenType

The type of a token


const enum TokenType {
		none                           = 0,                       // Nothing special
		url                            = 1,                       // A url
		email                          = 2,                       // An email address
		date                           = 3,                       // A date
		time                           = 4,                       // A time
		currency                       = 5,                       // A currency symbol
		number                         = 6,                       // A number
		punctuation                    = 7,                       // Punctuation characters
		numericPhrase                  = 8,                       // A numeric phrase
		weight                         = 9,                       // A weight (e.g. 5kgs)
		length                         = 10,                      // A length (e.g. 2km)
		temperature                    = 11,                      // A temperature (e.g. 5c)
		speed                          = 12,                      // A speed (e.g. 100kmh)
		volume                         = 13,                      // A volume
		area                           = 14,                      // An area
		person                         = 15,                      // A person
		malePerson                     = 16,                      // A male person
		femalePerson                   = 17,                      // A female person
		group                          = 18,                      // An organisation or group
		location                       = 19,                      // A location
		noun                           = 20,                      // A noun
		nounPhrase                     = 21,                      // A noun phrase
		prepositionPhrase              = 22,                      // A preposition phrase
		subject                        = 23,                      // A verb phrase subject
		object                         = 24,                      // A verb phrase object
		verb                           = 25,                      // A verb
		presentSimple                  = 26,                      // A present tense verb phrase
		presentContinuous              = 27,                      // A present continuous tense verb phrase
		presentPerfect                 = 28,                      // A present perfect tense verb phrase
		presentPerfectContinuous       = 29,                      // A present perfect continuous tense verb phrase
		pastSimple                     = 30,                      // A past tense verb phrase
		pastContinuous                 = 31,                      // A past continuous tense verb phrase
		pastPerfect                    = 32,                      // A past perfect tense verb phrase
		pastPerfectContinuous          = 33,                      // A past perfect continuous tense verb phrase
		futureSimple                   = 34,                      // A future tense verb phrase
		futureContinuous               = 35,                      // A future continuous tense verb phrase
		futurePerfect                  = 36,                      // A future perfect tense verb phrase
		futurePerfectContinuous        = 37,                      // A future perfect continuous tense verb phrase
		futureInPast                   = 38,                      // A future in past tense verb phrase
		usedTo                         = 39,                      // A "used to" verb phrase
		wouldAlways                    = 40,                      // A "would always" verb phrase
		infinitive                     = 41,                      // Infinitive verb phrase
		max                            = 42,                      // Maximum value
	}

WeightInitialisationType


const enum WeightInitialisationType {
		gaussian                       = 0,                       // 
		xavier                         = 1,                       // 
	}

WordnetPartOfSpeech

Part of speech for WordNet sense indices


const enum WordnetPartOfSpeech {
		unknown                        = 0,                       // Not known
		noun                           = 1,                       // Noun
		verb                           = 2,                       // Verb
		adjective                      = 3,                       // Adjective
		adjectiveSatellite             = 4,                       // Adjective satellite. See https://wordnet.princeton.edu/wordnet/man/wngloss.7WN.html
		adverb                         = 5,                       // Adverb
		punctuation                    = 6,                       // Punctuation
	}