Ice Blue Digital

Fantasia API

Fantasia API

[API documentation is currently incomplete and subject to change...]

Fantasia offers a complete suite of natural language processing, metadata, and content management services - all accessible through a single API.

This can be used as the basis for a headless (and yet intelligent) CMS, or to power your own unique applications.

Create an account to get an API key that you can use as soon as Fantasia becomes publicly available.

Account

[GET] /api/account/credit => unsigned integer

Returns the number of remaining API credits

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

Returns the current list of your active Fantasia subscriptions

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

Returns information on Fantasia usage history

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

Returns the resource counts only (limited subset of subscription/list)

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

WordNet

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

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

Parameter Type Description
query string The word to query

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

Returns a WordNet sense index

Parameter Type Description
sid unsigned integer The sense index id

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

Returns an expanded WordNet sense index

Parameter Type Description
sid unsigned integer The sense index id

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

Returns topics associated with a sense index

Parameter Type Description
sid unsigned integer The sense index id

Topics

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

Returns the total number of topics

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

Returns a topic from the topic ontology

Parameter Type Description
topicId unsigned integer The topic id

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

Returns a list of topics

Parameter Type Description
topicIds string Pipe separated list of topic ids

[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.

Parameter Type Description
query string The topic to search for
start unsigned integer - (optional)
count unsigned integer - (optional)

[GET] /api/topic/all?c={category} => TopicInfo[]

Returns topics associated with the topic category

Parameter Type Description
category string -

[GET] /api/topic/list?sid={senseIndex} => TopicInfo[]

Returns topics associated with the given WordNet sense index

Parameter Type Description
senseIndex unsigned integer -

Bookmarks

[GET] /api/bookmark/list?q={query}&t={type}&s={start}&c={count} => PagedResponse of BookmarkInfo

Returns a page of bookmarks

Parameter Type Description
query string Search text (optional)
type string Type of bookmarks to return {unclassified, archive or link} or null for all types (optional)
start unsigned integer Start offset (optional)
count unsigned integer Count to return (optional)

[POST] /api/bookmark?ct={contentType} => StatusMessage

Adds a file containing a list of bookmarks. File content can be a text file with a list of hyperlinks or an exported html file with bookmarks.

Message Body

Bookmark data file

Parameter Type Description
contentType string File content type. Can be text/plain or text/html

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

Deletes a bookmark

Parameter Type Description
id string Bookmark id

[POST] /api/bookmark/{id}/unclassified => bool

Archives the page behind the bookmark

Parameter Type Description
id string Bookmark id

[POST] /api/bookmark/{id}/archive => bool

Archives the page behind the bookmark

Parameter Type Description
id string Bookmark id

[POST] /api/bookmark/{id}/link => bool

Converts the bookmark to a link

Parameter Type Description
id string Bookmark id

[POST] /api/bookmark{id}/refresh => StatusMessage

Parameter Type Description
id string -

[POST] /api/bookmark?url={bookmarkUrl} => AddBookmarkResponse

Add a new bookmark

Parameter Type Description
bookmarkUrl string Url of the bookmark to add

Documents

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

Returns document meta data

Parameter Type Description
documentTitle string Document title

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

Returns all document tags

[GET] /api/document/writeable => DocumentInfo[]

Returns a list of all writeable documents

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

Returns a page of documents

Parameter Type Description
query string Optional search query (optional)
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool True to only return flagged documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)
start unsigned integer Start offset (optional)
count unsigned integer Count of documents in page (optional)

[GET] /api/document/{id}/content => DocumentContent

Returns document content

Parameter Type Description
id string Document id

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

Returns document JSON

Parameter Type Description
id string Document id

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

Returns document JSON

Parameter Type Description
documentTitle string Document title

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

Returns document meta data

Parameter Type Description
documentId string -

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

Updates document JSON

Message Body

Document JSON

Parameter Type Description
id string Document id

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

Appends static html to a document

Message Body

HTML to append

Parameter Type Description
id string Document id
fromUrl string Url that the HTML came from

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

Gets documents related to the specified document

Parameter Type Description
id string Document id
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (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

Parameter Type Description
id string Document id
paragraphIds string Pipe separated list of paragraph ids
start unsigned integer Start offset (optional)
count unsigned integer Paragraph count (optional)

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

Returns the sentences from a document

Parameter Type Description
id string Document id

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

Returns a ranked list of topics from a document

Parameter Type Description
id string Document id

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

Deletes a document

Parameter Type Description
id string Document id

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

Creates a new editable document

Parameter Type Description
documentTitle string Document title (optional)

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

Updates an editable document

Message Body

Document JSON

Parameter Type Description
id string Document id

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

Sets a flag on the document

Parameter Type Description
id string Document id

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

Removes a flag on the document

Parameter Type Description
id string Document id

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

Adds a tag to a document

Parameter Type Description
id string Document id
tag string Tag to add

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

Removes a tag from a document

Parameter Type Description
id string Document id
tag string Tag to remove

[GET] /api/document/favicon/{favIconId} => string

Returns the document's fav icon as a data URI

Parameter Type Description
favIconId int Fav Icon Id

Document Topics

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

Searches for topics within documents

Parameter Type Description
query string Search query
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)
start unsigned integer Start offset (optional)
count unsigned integer Topic count to return (optional)

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

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

Parameter Type Description
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)
start unsigned integer Start offset (optional)
count unsigned integer Topic count to return (optional)

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

Returns the sentence that contain all topic ids

Parameter Type Description
topicQuery string Pipe delimited list of topic ids
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)
start unsigned integer Start offset (optional)
count unsigned integer Topic count to return (optional)

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

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

Parameter Type Description
senseIndex unsigned integer Sense index to query
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)

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

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

Parameter Type Description
category string Document cateogory
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)

Files

[POST] /api/file?title={documentTitle} => AddFileResponse

Adds a file to analyse

Message Body

File content

Parameter Type Description
documentTitle string Title to give the document

Images

[GET] /api/image/list?q={query}&s={start}&c={count} => PagedResponse of ImageInfo

Returns a page of images

Parameter Type Description
query string Optional search query (optional)
start unsigned integer Start offset (optional)
count unsigned integer Image count to return (optional)

[GET] /api/image/{id}/data => ImageData

Returns image data

Parameter Type Description
id string Image id

[POST] /api/image?title={imageTitle}&desc={imageDescription} => AddFileResponse

Adds a new image

Message Body

Binary image data

Parameter Type Description
imageTitle string Image title
imageDescription string Image description (optional) (optional)

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

Updates image meta data

Message Body

Image meta data

Parameter Type Description
id string Image id

[GET] /api/image/{id}/thumbnail/data => ImageData

Returns image thumbnail data

Parameter Type Description
id string Image id

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

Deletes an image

Parameter Type Description
id string Image id

Jobs

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

Returns a list of lodged jobs

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

Returns the status of a particular job

Parameter Type Description
id string Job id

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

Deletes a job

Parameter Type Description
id string Job 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

Parameter Type Description
id string Job 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

Parameter Type Description
id string Job 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

Parameter Type Description
id string Job 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

Parameter Type Description
id string Job 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

Parameter Type Description
id string Job id

Search

[GET] /api/search/text?q={query}&t={tags}&f={flagged}&rt={type}&s={start}&c={count} => PagedResponse of SearchResult

Searches document content

Parameter Type Description
query string Search query
tags string Pipe separated tags to filter documents (only documents with ANY tag) (optional)
flagged bool Optional flagged status filter on documents (optional)
type string Optional resource type (pipe separated list of "document", "file" or "page") (optional)
start unsigned integer Start offset (optional)
count unsigned integer Result count (optional)

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

Analyses a search query

Parameter Type Description
query string Search query text

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

Finds related paragraphs

Parameter Type Description
documentId string Document id
paragraphIds string Pipe separated list of paragraph ids
start unsigned integer Start offset (optional)
count unsigned integer Result count (optional)

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

Finds paragraphs related to the text

Message Body

Text to analyse

Parameter Type Description
start unsigned integer Start offset (optional)
count unsigned integer Result count (optional)

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

Search topics that are associated with documents

Parameter Type Description
query string Search query
start unsigned integer Start offset (optional)
count unsigned integer Result count (optional)

Structured Types

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

Parameter Type Description
start unsigned integer (optional)
count unsigned integer (optional)

[GET] /api/type/{id} => StructuredTypeInfo

Parameter Type Description
id string

[POST] /api/type?title={title} => StructuredTypeInfo

Parameter Type Description
title string

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

Updates

Message Body

Structured type definition

Parameter Type Description
id string Structured type id

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

Updates the structured type definition

Message Body

JSON that defines the type

Parameter Type Description
id string Structured type id

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

Deletes a structured type

Parameter Type Description
id string Structured type id

Data Tables

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

Returns a list of data tables

Parameter Type Description
start unsigned integer Start index (optional)
count unsigned integer Count to return (optional)

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

Returns information about a data table

Parameter Type Description
id string Data table id

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

Returns a page of data from a data table

Parameter Type Description
id string Data table id
start unsigned integer First row index to return (optional)
count unsigned integer Count of rows to return (optional)

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

Updates the data table meta data

Message Body

Data table definition

Parameter Type Description
id string Data table id

[GET] /api/table/{id}/metadata => DataTableColumn[]

Returns column meta data for the specified table

Parameter Type Description
id string Data table id

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

Updates the data table's column names

Message Body

Data table column definitions

Parameter Type Description
id string Data table id

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

Deletes the data table

Parameter Type Description
id string Data table id

Analysis

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

Performs a semantic analysis on the text

Message Body

The text to analyse

Interfaces

AccountUsage

Counts associated with an account's Fantasia usage

interface AccountUsage {
	bookmarkCount:                 number,                  // Bookmark count
	documentCount:                 number,                  // Document count
	documentSize:                  number,                  // Size in bytes of documnts
	fileCount:                     number,                  // Count of files
	fileSize:                      number,                  // Size in bytes of files
	pageCount:                     number,                  // Count of archived bookmarks
	pageSize:                      number,                  // Size in bytes of archived bookmarks
	imageCount:                    number,                  // Image count
	imageSize:                     number,                  // Size in bytes of images
	structuredTypeCount:           number,                  // Structured type count
	structuredTypeSize:            number,                  // Size in bytes of structured types
	dataTableCount:                number,                  // Data table count
	dataTableSize:                 number,                  // Size in bytes of data tables
	apiUsage:                      number,                  // Count of API usage
	bandwidthUsage:                number,                  // Bandwidth usage
	topicCount:                    number,                  // Count of topics that have been associated with documents
}

AddBookmarkResponse

Response message after adding a bookmark

interface AddBookmarkResponse extends StatusMessage {
	bookmark:                      BookmarkInfo,            // The bookmark that was added
}

AddFileResponse

Response message after adding a file

interface AddFileResponse extends StatusMessage {
	document:                      DocumentInfo,            // Information about the newly added file
	image:                         ImageInfo,               // Information about the newly added image
}

AnalysedWord

Word with expanded topics and senses

interface AnalysedWord {
	text:                          string,                  // Word text
	lemma:                         string,                  // Base form of word (optional)
	pos:                           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
}

Block

Document block

interface Block {
	type:                          BlockType,               // Type of the block
	data:                          JObject,                 // Data associated with the block
}

BookmarkInfo

Bookmark information

interface BookmarkInfo {
	id:                            string,                  // Bookmark id
	title:                         string,                  // Bookmark title
	description:                   string,                  // Bookmark description
	url:                           string,                  // Url associated with the bookmark
	dateCreated?:                  Date,                    // Date the bookmark was created
	shortUrl:                      string,                  // Short version of the URL
	hasPage:                       boolean,                 // True if the bookmark has an associated page
	isIndexed:                     boolean,                 // True if the associated page has been indexed
	pageId:                        string,                  // Id of the associated page
	shouldRefresh:                 boolean,                 // True if the bookmark should be re-archived
	message:                       string,                  // Message generated when attempting to save the bookmark (optional)
	failedDownload:                boolean,                 // True if the bookmark could not be archived
	type:                          BookmarkType,            // Type of bookmark
}

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
}

DataTableData

Data from a table

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

DataTableInfo

Data table information

interface DataTableInfo {
	id:                            string,                  // Data table id
	documentId:                    string,                  // Associated document id
	numRows:                       number,                  // Total number of rows in the table
	size:                          number,                  // Table size in bytes
	title:                         string,                  // Table name
	description:                   string,                  // Table description
}

DataTableRow

A row in a data table

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

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
	type:                          ResourceType,            // Document type
	dateCreated:                   Date,                    // Date created
	title:                         string,                  // Main document title
	description:                   string,                  // Short document description
	isFlagged:                     boolean,                 // True if the document is flagged
	tag:                           string[],                // List of tags (optional)
	contentType:                   string,                  // Document content type (optional)
	favIconId?:                    number,                  // The fav icon id (optional)
	url:                           string,                  // If the document is a bookmark, then URL of the source page (optional)
	shortUrl:                      string,                  // Short version of URL (above)
	isAvailable:                   boolean,                 // True if the document has data
}

DocumentSentences

Document parse results

interface DocumentSentences {
	paragraphs:                    Paragraph[],             // 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:                          ResourceType,            // 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 {
	expandedPointer:               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)
}

Fragment

A fragment of search result text

interface Fragment {
	spans:                         Span[],                  // An array of spans, each with different hilights
}

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
}

ImageData

Image data

interface ImageData {
	info:                          ImageInfo,               // Image information
	data:                          string,                  // Image data URI (encoded as base64)
}

ImageInfo

Image information

interface ImageInfo {
	id:                            string,                  // Unique image id
	hash:                          string,                  // Image content hash
	size:                          number,                  // Size in bytes
	width:                         number,                  // Image width
	height:                        number,                  // Image height
	contentType:                   string,                  // Image content type
	title:                         string,                  // Image title
	caption:                       string,                  // Image caption
}

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
}

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
	span:                          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
}

Paragraph

A paragraph

interface Paragraph {
	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
}

Property

A property of a structured type

interface Property {
	id:                            string,                  // Unique property id
	type:                          PropertyType,            // Property type
	dataType:                      DataType,                // Property data type
	name:                          string,                  // Property name
	description:                   string,                  // Property description
	displayHint:                   DisplayHint,             // A hint about how to edit property values
	expectedLength:                number,                  // Expected property length
	values:                        string[],                // List of possible property values
	defaultValue:                  string,                  // Default property value
	defaultChecked:                boolean,                 // True if the property is checked by default
	typeReferenceId:               string,                  // The structured type id that this property refers to
	children:                      Property[],              // Property children
	isList:                        boolean,                 // True if the property can hold a list of values
	isOptional:                    boolean,                 // True if the property is optional
	isHidden:                      boolean,                 // True if the property should not be displayed in an editor
}

QueryWord

Search query word

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

QuestionAnalysisResults

Question analysis results

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

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 {
	id:                            string,                  // Unique document id
	type:                          ResourceType,            // Type of document
	title:                         string,                  // Document title
	description:                   string,                  // Document description
	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
}

SearchResult

Search result

interface SearchResult {
	content:                       Fragment[],              // Search result fragment array
	displayUrl:                    Fragment,                // The display url
	title:                         string,                  // Search result title
	description:                   string,                  // Search result description
	id:                            string,                  // Unique document id
	type:                          ResourceType,            // Document resource type
	shortUrl:                      string,                  // Short document display url (optional)
	favIconId?:                    number,                  // Fav icon id (optional)
	topics:                        TopicInfo[],             // Array of matching document topics
}

SearchResultList

List of search results

interface SearchResultList {
	query:                         string,                  // Search query
	results:                       PagedResponse,        // Page of results
	suggestion:                    string[],                // Array of possible suggestions (if nothing was found)
}

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
	classification:                string[],                // List of words that specify the sense index domain (optional)
	definition:                    GlossWord[],             // List of words in the definition
	example:                       string[],                // List of example sentences (optional)
	pointer:                       SensePointer[],          // List of pointers to related sense indices
	verbFrame:                     VerbFrame[],             // List of verb frames (optional)
	uniqueId:                      string,                  // Unique string id
	id:                            number,                  // Numeric id
}

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
	sentenceIndex:                 SentenceIndex[],         // Array of token annotations
}

Sentence

Parsed sentence

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

SentenceIndex

Token annotation

interface SentenceIndex {
	type:                          TokenType,               // Token type
	pos:                           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:                          ResourceType,            // 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
}

Span

A span of text

interface Span {
	text:                          string,                  // The text itself
	hilightGroup:                  number,                  // A hilight index for this text
}

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
	size?:                         number,                  // API usage associated with this subscription
}

TextAnalysisResults

Results from text analysis

interface TextAnalysisResults {
	id:                            string,                  // A temporary id that refers to this text analysis
	token:                         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
	pos:                           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 {
	pos:                           PartOfSpeech,            // Token part of speech
	text:                          string,                  // Token text
	tokenType:                     TokenType[],             // Array of token types
	senseIndices:                  number[],                // Array of possible sense indices
	topicIds:                      number[],                // Array of possible topic ids
	topic:                         UserTopicInfo[],         // Possible topic connections
}

TokenisationResult

Tokenisation results

interface TokenisationResult {
	text:                          string,                  // Normalised text
	tokens:                        SimpleToken[],           // Array of tokens
}

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
	topic:                         TopicInfo[],             // Array of topics from query
	relatedTopic:                  TopicInfo[],             // Array of related topics
	sentenceText:                  DocumentTopicSentences[],// Array of matching documents
	total:                         number,                  // Total number of results
	offset:                        number,                  // Request page offset
}

UserTopicInfo

Information about a topic and if it appears in the document collection

interface UserTopicInfo {
	topic:                         TopicInfo,               // Topic information
	appearsInDocuments:            boolean,                 // True if this document has been identified in the document collection
}

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)
	pos:                           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
}

WordnetSearchResults

WordNet search results

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

Enums

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
	}

BookmarkType

Type of bookmark


const enum BookmarkType {
		unclassified                   = 0,                       // Not classified
		archive                        = 1,                       // Page should be archived
		link                           = 2,                       // Not archived
	}

CodeEditorType

Source code editor type


const enum CodeEditorType {
		plain                          = 0,                       // Plain text
		javaScript                     = 1,                       // JavaScript
		typeScript                     = 2,                       // TypeScript
		html                           = 3,                       // HTML
		css                            = 4,                       // CSS
		sass                           = 5,                       // SASS
		less                           = 6,                       // LESS
		go                             = 7,                       // Go
		fSharp                         = 8,                       // F#
		octave                         = 9,                       // Octave
		python                         = 10,                      // Python
		r                              = 11,                      // R
		sql                            = 12,                      // SQL
		mySQL                          = 13,                      // MySQL
		plsql                          = 14,                      // PL/SQL
		sQLServer                      = 15,                      // SQL Server
		xml                            = 16,                      // XML
		json                           = 17,                      // JSON
		jsx                            = 18,                      // JSX (React)
		jSXTypeScript                  = 19,                      // JSX with TypeScript (React)
		c                              = 20,                      // C
		cPlusPlus                      = 21,                      // C++
		cSharp                         = 22,                      // C#
		java                           = 23,                      // Java
	}

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
	}

DisplayHint

Type property display hint


const enum DisplayHint {
		none                           = 0,                       // Nothing special
		long                           = 1,                       // Long text
		html                           = 2,                       // Rich text (HTML)
		image                          = 3,                       // Image
		date                           = 4,                       // Date
		time                           = 5,                       // Time
		url                            = 6,                       // Url
		colour                         = 7,                       // Colour
		password                       = 8,                       // Password
	}

JobType

The type of job


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

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.
		domainOfSynset_category        = 12,                      // Related by category
		domainOfSynset_region          = 13,                      // Related by region
		domainOfSynset_usage           = 14,                      // Related by usage
		memberOfDomain_category        = 15,                      // Related by category
		memberOfDomain_region          = 16,                      // Related by region
		memberOfDomain_usage           = 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
	}

PropertyType

Structured property type


const enum PropertyType {
		unknown                        = 0,                       // Not set
		literal                        = 1,                       // Literal property (string, number, boolean)
		set                            = 2,                       // One of a set of possible values
		object                         = 3,                       // A composite property defined with its children
		any                            = 4,                       // Property can take any form
	}

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
	}

ResourceType

Type of resource


const enum ResourceType {
		document                       = 0,                       // Editable document
		file                           = 1,                       // Uploaded file
		page                           = 2,                       // Page archived from a bookmark
		bookmark                       = 3,                       // Saved bookmark
		image                          = 4,                       // Image
		structuredType                 = 5,                       // Structured data
		dataTable                      = 6,                       // Data table
		max                            = 7,                       // Max possible 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
	}

WordnetPartOfSpeech

Part of speech for WordNet sense indices


const enum WordnetPartOfSpeech {
		unknown                        = 0,                       // Not knowne
		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
	}