I extracted the types from jsdocs using a template "tsd-jsdoc" & made some changes. The namespace had to be renamed & rearranged.
The following code works for me Hope its gonna help others.
// jsdoc node_modules/corenlp/dist/ -t node_modules/tsd-jsdoc/dist -r
/**
* @class
* @classdesc Class representing a Connector CLI (command line interface client)
*/
export class ConnectorCli {
constructor(config: {
classPath: string;
mainClass: string;
props: string;
});
/**
* @returns {Promise<Object>}
*/
get(): Promise<any>;
/**
* @returns {Promise<Object>}
*/
get(): Promise<any>;
}
/**
* @class
* @classdesc Class representing a Connector Server (web server client)
*/
export class ConnectorServer {
constructor(config: {
dsn: string;
username?: string;
// username?: string;
});
/**
* @param {Object} config
* @param {Array.<string>} config.annotators - The list of annotators that defines the pipeline
* @param {string} config.text - The text to run the pipeline against
* @param {Object} config.options - Additinal options (properties) for the pipeline
* @param {string} config.language - Language full name in CamelCase (eg. Spanish)
* @param {(''|'tokensregex'|'semgrex'|'tregex')} [utility] - Name of the utility to use
* NOTE: most of the utilities receives properties, these should be passed via the options param
* @returns {Promise<Object>}
*/
get(config: {
annotators: string[];
text: string;
options: any;
language: string;
}, utility?: '' | 'tokensregex' | 'semgrex' | 'tregex'): Promise<any>;
/**
* @param {Object} config
* @param {Array.<string>} config.annotators - The list of annotators that defines the pipeline
* @param {string} config.text - The text to run the pipeline against
* @param {Object} config.options - Additinal options (properties) for the pipeline
* @param {string} config.language - Language full name in CamelCase (eg. Spanish)
* @param {(''|'tokensregex'|'semgrex'|'tregex')} [utility] - Name of the utility to use
* NOTE: most of the utilities receives properties, these should be passed via the options param
* @returns {Promise<Object>}
*/
get(config: {
annotators: string[];
text: string;
options: any;
language: string;
}, utility?: '' | 'tokensregex' | 'semgrex' | 'tregex'): Promise<any>;
}
export namespace CoreNLP {
/**
* @namespace CoreNLP/simple
* @description NodeJS API that emulates {@link https://stanfordnlp.github.io/CoreNLP/simple.html}
*/
namespace simple {
/**
* @class
* @classdesc Class representing an Annotable
* @memberof CoreNLP/simple
*/
class Annotable {
constructor(text: string);
/**
* Get a string representation of the raw text
* @return {string} text
*/
text(): string;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* The language string should be passed in lowercase ISO2 format
* @return {string} text
*/
setLanguageISO(): string;
/**
* Retrieves the language ISO (in lowercase ISO2 format)
* @return {string} iso
*/
getLanguageISO(): string;
/**
* Marks an annotator as a met dependency
* @param {Annotator|function} annotator
*/
addAnnotator(annotator: Annotator | ((...params: any[]) => any)): void;
/**
* Marks multiple annotators as a met dependencies
* @param {Array.<Annotator|function>} annotators
*/
addAnnotators(annotators: (Annotator | ((...params: any[]) => any))[]): void;
/**
* Unmarks an annotator as a met dependency
* @param {Annotator|function} annotator
*/
removeAnnotator(annotator: Annotator | ((...params: any[]) => any)): void;
/**
* Tells you if an annotator is a met dependency
* @param {Annotator|function} annotator
* @returns {boolean} hasAnnotator
*/
hasAnnotator(annotator: Annotator | ((...params: any[]) => any)): boolean;
/**
* Tells you if at least on of a list of annotators is a met dependency
* @param {Array.<Annotator|function>} annotators
* @returns {boolean} hasAnyAnnotator
*/
hasAnyAnnotator(annotators: (Annotator | ((...params: any[]) => any))[]): boolean;
/**
* Get a string representation of the raw text
* @return {string} text
*/
text(): string;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* The language string should be passed in lowercase ISO2 format
* @return {string} text
*/
setLanguageISO(): string;
/**
* Retrieves the language ISO (in lowercase ISO2 format)
* @return {string} iso
*/
getLanguageISO(): string;
/**
* Marks an annotator as a met dependency
* @param {Annotator|function} annotator
*/
addAnnotator(annotator: Annotator | ((...params: any[]) => any)): void;
/**
* Marks multiple annotators as a met dependencies
* @param {Array.<Annotator|function>} annotators
*/
addAnnotators(annotators: (Annotator | ((...params: any[]) => any))[]): void;
/**
* Unmarks an annotator as a met dependency
* @param {Annotator|function} annotator
*/
removeAnnotator(annotator: Annotator | ((...params: any[]) => any)): void;
/**
* Tells you if an annotator is a met dependency
* @param {Annotator|function} annotator
* @returns {boolean} hasAnnotator
*/
hasAnnotator(annotator: Annotator | ((...params: any[]) => any)): boolean;
/**
* Tells you if at least on of a list of annotators is a met dependency
* @param {Array.<Annotator|function>} annotators
* @returns {boolean} hasAnyAnnotator
*/
hasAnyAnnotator(annotators: (Annotator | ((...params: any[]) => any))[]): boolean;
}
/**
* @class
* @classdesc Class representing an Annotatror
* @memberof CoreNLP/simple
*/
class Annotator {
constructor(name: string, options?: any, dependencies?: Annotator[]);
/**
* Get a string representation
* @return {string} annotator
*/
toString(): string;
/**
* Defines whether a given annotator is the same as current, using shallow compare.
* This is useful for a Document or Sentence to validate if the minimum of annotators required
* were already applied to them. Allows at the same time the users to instantiate new annotators
* and configure them as needed.
* @param {Annotator} annotator
* @return {boolean}
*/
equalsTo(annotator: Annotator): boolean;
/**
* Get an Object key-value representation of the annotor's options (excluding prefix)
* @return {Object} options
*/
options(): any;
/**
* Get/Set an option value
* @param {string} key
* @param {string|boolean} [value]
* @return {string} value
*/
option(key: string, value?: string | boolean): string;
/**
* Get a list of annotators dependencies
* @return {Array.<Annotator>} dependencies
*/
dependencies(): Annotator[];
/**
* Get a list of annotators dependencies, following by this annotator, all this as
* a list of strings
* This is useful to fulfill the 'annotators' param in CoreNLP API properties.
* @return {Array.<string>} pipeline
*/
pipeline(): string[];
/**
* Get an object of all the Annotator options including the current and all its
* dependencies, prefixed by the annotator names
* This is useful to fulfill the options params in CoreNLP API properties.
* @return {Array.<string>} pipelineOptions
*/
pipelineOptions(): string[];
/**
* Get a string representation
* @return {string} annotator
*/
toString(): string;
/**
* Defines whether a given annotator is the same as current, using shallow compare.
* This is useful for a Document or Sentence to validate if the minimum of annotators required
* were already applied to them. Allows at the same time the users to instantiate new annotators
* and configure them as needed.
* @param {Annotator} annotator
* @return {boolean}
*/
equalsTo(annotator: Annotator): boolean;
/**
* Get an Object key-value representation of the annotor's options (excluding prefix)
* @return {Object} options
*/
options(): any;
/**
* Get/Set an option value
* @param {string} key
* @param {string|boolean} [value]
* @return {string} value
*/
option(key: string, value?: string | boolean): string;
/**
* Get a list of annotators dependencies
* @return {Array.<Annotator>} dependencies
*/
dependencies(): Annotator[];
/**
* Get a list of annotators dependencies, following by this annotator, all this as
* a list of strings
* This is useful to fulfill the 'annotators' param in CoreNLP API properties.
* @return {Array.<string>} pipeline
*/
pipeline(): string[];
/**
* Get an object of all the Annotator options including the current and all its
* dependencies, prefixed by the annotator names
* This is useful to fulfill the options params in CoreNLP API properties.
* @return {Array.<string>} pipelineOptions
*/
pipelineOptions(): string[];
}
/**
* @class
* @classdesc Class representing a Document
* @extends Annotable
* @memberof CoreNLP/simple
*/
class Document extends Annotable {
constructor(text: string);
/**
* Get a string representation
* @return {string} document
*/
toString(): string;
/**
* Get a list of sentences
* @returns {Array.<Sentence>} sentences - The document sentences
*/
sentences(): Sentence[];
/**
* Get the sentence for a given index
* @param {number} index - The position of the sentence to get
* @returns {Sentence} sentence - The document sentences
*/
sentence(index: number): Sentence;
/**
* @todo Missing implementation
* @see https://stanfordnlp.github.io/CoreNLP/dcoref.html
* @returns {Array.<CorefChain>}
*/
corefs(): CorefChain[];
/**
* Get the coreference for a given index
* @param {number} index - 0-based index of the coref chain list
* @see https://stanfordnlp.github.io/CoreNLP/dcoref.html
* @returns {CorefChain}
*/
coref(index: number): CorefChain;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Update an instance of Document with data provided by a JSON
* @param {DocumentJSON} data - The document data, as returned by CoreNLP API service
* @returns {Document} document - The current document instance
*/
fromJSON(data: DocumentJSON): Document;
/**
* Get an instance of Document from a given JSON
* @param {DocumentJSON} data - The document data, as returned by CoreNLP API service
* @returns {Document} document - A new Document instance
*/
static fromJSON(data: DocumentJSON): Document;
/**
* Get a string representation
* @return {string} document
*/
toString(): string;
/**
* Get a list of sentences
* @returns {Array.<Sentence>} sentences - The document sentences
*/
sentences(): Sentence[];
/**
* Get the sentence for a given index
* @param {number} index - The position of the sentence to get
* @returns {Sentence} sentence - The document sentences
*/
sentence(index: number): Sentence;
/**
* @todo Missing implementation
* @see https://stanfordnlp.github.io/CoreNLP/dcoref.html
* @returns {Array.<CorefChain>}
*/
corefs(): CorefChain[];
/**
* Get the coreference for a given index
* @param {number} index - 0-based index of the coref chain list
* @see https://stanfordnlp.github.io/CoreNLP/dcoref.html
* @returns {CorefChain}
*/
coref(index: number): CorefChain;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Update an instance of Document with data provided by a JSON
* @param {DocumentJSON} data - The document data, as returned by CoreNLP API service
* @returns {Document} document - The current document instance
*/
fromJSON(data: DocumentJSON): Document;
/**
* Get an instance of Document from a given JSON
* @param {DocumentJSON} data - The document data, as returned by CoreNLP API service
* @returns {Document} document - A new Document instance
*/
static fromJSON(data: DocumentJSON): Document;
}
/**
* @class
* @classdesc Class representing an Expression
* @extends Annotable
* @memberof CoreNLP/simple
*/
class Expression extends Annotable {
constructor(text: string, pattern: string);
/**
* Get a string representation
* @return {string} expression
*/
toString(): string;
/**
* Get the pattern
* @returns {string} pattern - The expression pattern
*/
pattern(): string;
/**
* Get a list of sentences
* @returns {Array.<ExpressionSentence>} sentences - The expression sentences
*/
sentences(): ExpressionSentence[];
/**
* Get the sentence for a given index
* @param {number} index - The position of the sentence to get
* @returns {ExpressionSentence} sentence - An expression sentence
*/
sentence(index: number): ExpressionSentence;
/**
* Hydrate the Expression instance with Token objects from an annotated Document
* @see {@link ExpressionSentence#mergeTokensFromSentence}
* @param {Document} document - An annotated document from where to extract the tokens
* @returns {Expression} expression - The current expression instance
*/
mergeTokensFromDocument(document: Document): Expression;
/**
* Update an instance of Expression with data provided by a JSON
* @param {ExpressionJSON} data - The expression data, as returned by CoreNLP API service
* @returns {Expression} expression - The current expression instance
*/
fromJSON(data: ExpressionJSON): Expression;
/**
* Get an instance of Expression from a given JSON
* @param {ExpressionJSON} data - The expression data, as returned by CoreNLP API service
* @returns {Expression} expression - A new Expression instance
*/
static fromJSON(data: ExpressionJSON): Expression;
/**
* Get a string representation
* @return {string} expression
*/
toString(): string;
/**
* Get the pattern
* @returns {string} pattern - The expression pattern
*/
pattern(): string;
/**
* Get a list of sentences
* @returns {Array.<ExpressionSentence>} sentences - The expression sentences
*/
sentences(): ExpressionSentence[];
/**
* Get the sentence for a given index
* @param {number} index - The position of the sentence to get
* @returns {ExpressionSentence} sentence - An expression sentence
*/
sentence(index: number): ExpressionSentence;
/**
* Hydrate the Expression instance with Token objects from an annotated Document
* @see {@link ExpressionSentence#mergeTokensFromSentence}
* @param {Document} document - An annotated document from where to extract the tokens
* @returns {Expression} expression - The current expression instance
*/
mergeTokensFromDocument(document: Document): Expression;
/**
* Update an instance of Expression with data provided by a JSON
* @param {ExpressionJSON} data - The expression data, as returned by CoreNLP API service
* @returns {Expression} expression - The current expression instance
*/
fromJSON(data: ExpressionJSON): Expression;
/**
* Get an instance of Expression from a given JSON
* @param {ExpressionJSON} data - The expression data, as returned by CoreNLP API service
* @returns {Expression} expression - A new Expression instance
*/
static fromJSON(data: ExpressionJSON): Expression;
}
/**
* @class
* @classdesc Class representing a Governor
* @memberof CoreNLP/simple
*/
class Governor {
constructor(dep: string, dependentToken: Token, governorToken?: Token);
/**
* Get a string representation
* @return {string} governor
*/
toString(): string;
/**
* Get an instance of Governor from a given JSON
*
* @todo It is not possible to properly generate a Governor from a GovernorJSON
* the Governor requires references to the Token instances in order to work
* @param {GovernorJSON} data - The token data, as returned by CoreNLP API service
* @returns {Governor} governor - A new Governor instance
*/
static fromJSON(data: GovernorJSON): Governor;
/**
* Get a string representation
* @return {string} governor
*/
toString(): string;
/**
* Get an instance of Governor from a given JSON
*
* @todo It is not possible to properly generate a Governor from a GovernorJSON
* the Governor requires references to the Token instances in order to work
* @param {GovernorJSON} data - The token data, as returned by CoreNLP API service
* @returns {Governor} governor - A new Governor instance
*/
static fromJSON(data: GovernorJSON): Governor;
}
/**
* @class
* @classdesc Class representing a Sentence
* @extends Annotable
* @memberof CoreNLP/simple
* @see {@link https://github.com/stanfordnlp/CoreNLP/blob/master/src/edu/stanford/nlp/simple/Sentence.java}
*/
class Sentence extends Annotable {
constructor(text: string);
/**
* Get a string representation
* @returns {string} sentence
*/
toString(): string;
/**
* Get the index relative to the parent document
* @returns {number} index
*/
index(): number;
/**
* Get a string representation of the parse tree structure
* @returns {string} parse
*/
parse(): string;
/**
* Get an array of string representations of the sentence words
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<string>} words
*/
words(): string[];
/**
* Get a string representations of the Nth word of the sentence
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} word
*/
word(index: number): string;
/**
* Get a string representations of the tokens part of speech of the sentence
* @returns {Array.<string>} posTags
*/
posTags(): string[];
/**
* Get a string representations of the Nth token part of speech of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} posTag
*/
posTag(index: number): string;
/**
* Get a string representations of the tokens lemmas of the sentence
* @returns {Array.<string>} lemmas
*/
lemmas(): string[];
/**
* Get a string representations of the Nth token lemma of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} lemma
*/
lemma(index: number): string;
/**
* Get a string representations of the tokens nerTags of the sentence
* @returns {Array.<string>} nerTags
*/
nerTags(): string[];
/**
* Get a string representations of the Nth token nerTag of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} nerTag
*/
nerTag(index: number): string;
/**
* Get a list of annotated governors by the dependency-parser
* @requires {@link DependencyParseAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<Governor>} governors
*/
governors(): Governor[];
/**
* Get the N-th annotated governor by the dependency-parser annotator
* @requires {@link DependencyParseAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Governor} governor
*/
governor(): Governor;
/**
* Get an array of token representations of the sentence words
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<Token>} tokens
*/
tokens(): Token[];
/**
* Get the Nth token of the sentence
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Token} token
*/
token(): Token;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Get a JSON representation of the current sentence
* @description
* The following arrow function 'data => Sentence.fromJSON(data).toJSON()' is idempontent, if
* considering shallow comparison, not by reference.
* This JSON will respects the same structure as it expects from {@see Sentence#fromJSON}.
* @returns {SentenceJSON} data
*/
toJSON(): SentenceJSON;
/**
* Update an instance of Sentence with data provided by a JSON
* @param {SentenceJSON} data - The document data, as returned by CoreNLP API service
* @param {boolean} [isSentence] - Indicate if the given data represents just the sentence
* or a full document with just a sentence inside
* @returns {Sentence} sentence - The current sentence instance
*/
fromJSON(data: SentenceJSON, isSentence?: boolean): Sentence;
/**
* Get an instance of Sentence from a given JSON
* @param {SentenceJSON} data - The document data, as returned by CoreNLP API service
* @param {boolean} [isSentence] - Indicate if the given data represents just the sentence of a
* full document
* @returns {Sentence} document - A new Sentence instance
*/
static fromJSON(data: SentenceJSON, isSentence?: boolean): Sentence;
/**
* Get a string representation
* @returns {string} sentence
*/
toString(): string;
/**
* Get the index relative to the parent document
* @returns {number} index
*/
index(): number;
/**
* Get a string representation of the parse tree structure
* @returns {string} parse
*/
parse(): string;
/**
* Get an array of string representations of the sentence words
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<string>} words
*/
words(): string[];
/**
* Get a string representations of the Nth word of the sentence
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} word
*/
word(index: number): string;
/**
* Get a string representations of the tokens part of speech of the sentence
* @returns {Array.<string>} posTags
*/
posTags(): string[];
/**
* Get a string representations of the Nth token part of speech of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} posTag
*/
posTag(index: number): string;
/**
* Get a string representations of the tokens lemmas of the sentence
* @returns {Array.<string>} lemmas
*/
lemmas(): string[];
/**
* Get a string representations of the Nth token lemma of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} lemma
*/
lemma(index: number): string;
/**
* Get a string representations of the tokens nerTags of the sentence
* @returns {Array.<string>} nerTags
*/
nerTags(): string[];
/**
* Get a string representations of the Nth token nerTag of the sentence
* @throws {Error} in case the token for the given index does not exists
* @param {number} index - 0-based index as they are arranged naturally
* @returns {string} nerTag
*/
nerTag(index: number): string;
/**
* Get a list of annotated governors by the dependency-parser
* @requires {@link DependencyParseAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<Governor>} governors
*/
governors(): Governor[];
/**
* Get the N-th annotated governor by the dependency-parser annotator
* @requires {@link DependencyParseAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Governor} governor
*/
governor(): Governor;
/**
* Get an array of token representations of the sentence words
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Array.<Token>} tokens
*/
tokens(): Token[];
/**
* Get the Nth token of the sentence
* @requires {@link TokenizerAnnotator}
* @throws {Error} in case the require annotator was not applied to the sentence
* @returns {Token} token
*/
token(): Token;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Get a JSON representation of the current sentence
* @description
* The following arrow function 'data => Sentence.fromJSON(data).toJSON()' is idempontent, if
* considering shallow comparison, not by reference.
* This JSON will respects the same structure as it expects from {@see Sentence#fromJSON}.
* @returns {SentenceJSON} data
*/
toJSON(): SentenceJSON;
/**
* Update an instance of Sentence with data provided by a JSON
* @param {SentenceJSON} data - The document data, as returned by CoreNLP API service
* @param {boolean} [isSentence] - Indicate if the given data represents just the sentence
* or a full document with just a sentence inside
* @returns {Sentence} sentence - The current sentence instance
*/
fromJSON(data: SentenceJSON, isSentence?: boolean): Sentence;
/**
* Get an instance of Sentence from a given JSON
* @param {SentenceJSON} data - The document data, as returned by CoreNLP API service
* @param {boolean} [isSentence] - Indicate if the given data represents just the sentence of a
* full document
* @returns {Sentence} document - A new Sentence instance
*/
static fromJSON(data: SentenceJSON, isSentence?: boolean): Sentence;
}
/**
* @class
* @classdesc Class representing a Token
* @extends Annotable
* @memberof CoreNLP/simple
*/
class Token extends Annotable {
constructor(word: string);
/**
* Get a string representation
* @returns {string} token
*/
toString(): string;
/**
* Get the 'inde ' number associated by the StanfordCoreNLP
* This index is relative to the sentence it belongs to, and is a 1-based (possitive integer).
* This number is useful to match tokens within a sentence for depparse, coreference, etc.
* @returns {number} index
*/
index(): number;
/**
* Get the original word
* @returns {string} word
*/
word(): string;
/**
* Get the original text
* @returns {string} originalText
*/
originalText(): string;
/**
* Get the characterOffsetBegin relative to the parent sentence
* @description
* A 0-based index of the word's initial character within the sentence
* @returns {number} characterOffsetBegin
*/
characterOffsetBegin(): number;
/**
* Get the characterOffsetEnd relative to the parent sentence
* A 0-based index of the word's ending character within the sentence
* @returns {number} characterOffsetEnd
*/
characterOffsetEnd(): number;
/**
* Get the 'before' string relative to the container sentence
* @returns {string} before
*/
before(): string;
/**
* Get the 'after' string relative to the container sentence
* @returns {string} after
*/
after(): string;
/**
* Get the annotated lemma
* @returns {string} lemma
*/
lemma(): string;
/**
* Get the annotated part-of-speech for the current token
* @returns {string} pos
*/
pos(): string;
/**
* Get additional metadata about the POS annotation
* NOTE: Do not use this method other than just for study or analysis purposes.
* @see {@link PosInfo} for more details
* @returns {PosInfo} posInfo
*/
posInfo(): PosInfo;
/**
* Get the annotated named-entity for the current token
* @returns {string} ner
*/
ner(): string;
/**
* Get the annotated speaker for the current token
* @see {@link CorefAnnotator}
* @returns {string} speaker
*/
speaker(): string;
/**
* Get a JSON representation of the current token
* @description
* The following arrow function 'data => Token.fromJSON(data).toJSON()' is idempontent, if
* considering shallow comparison, not by reference.
* This JSON will respects the same structure as it expects from {@see Token#fromJSON}.
* @returns {TokenJSON} data
*/
toJSON(): TokenJSON;
/**
* Get an instance of Token from a given JSON
* @param {TokenJSON} data - The token data, as returned by CoreNLP API service
* @returns {Token} token - A new Token instance
*/
static fromJSON(data: TokenJSON): Token;
/**
* Get a string representation
* @returns {string} token
*/
toString(): string;
/**
* Get the 'inde ' number associated by the StanfordCoreNLP
* This index is relative to the sentence it belongs to, and is a 1-based (possitive integer).
* This number is useful to match tokens within a sentence for depparse, coreference, etc.
* @returns {number} index
*/
index(): number;
/**
* Get the original word
* @returns {string} word
*/
word(): string;
/**
* Get the original text
* @returns {string} originalText
*/
originalText(): string;
/**
* Get the characterOffsetBegin relative to the parent sentence
* @description
* A 0-based index of the word's initial character within the sentence
* @returns {number} characterOffsetBegin
*/
characterOffsetBegin(): number;
/**
* Get the characterOffsetEnd relative to the parent sentence
* A 0-based index of the word's ending character within the sentence
* @returns {number} characterOffsetEnd
*/
characterOffsetEnd(): number;
/**
* Get the 'before' string relative to the container sentence
* @returns {string} before
*/
before(): string;
/**
* Get the 'after' string relative to the container sentence
* @returns {string} after
*/
after(): string;
/**
* Get the annotated lemma
* @returns {string} lemma
*/
lemma(): string;
/**
* Get the annotated part-of-speech for the current token
* @returns {string} pos
*/
pos(): string;
/**
* Get additional metadata about the POS annotation
* NOTE: Do not use this method other than just for study or analysis purposes.
* @see {@link PosInfo} for more details
* @returns {PosInfo} posInfo
*/
posInfo(): PosInfo;
/**
* Get the annotated named-entity for the current token
* @returns {string} ner
*/
ner(): string;
/**
* Get the annotated speaker for the current token
* @see {@link CorefAnnotator}
* @returns {string} speaker
*/
speaker(): string;
/**
* Get a JSON representation of the current token
* @description
* The following arrow function 'data => Token.fromJSON(data).toJSON()' is idempontent, if
* considering shallow comparison, not by reference.
* This JSON will respects the same structure as it expects from {@see Token#fromJSON}.
* @returns {TokenJSON} data
*/
toJSON(): TokenJSON;
/**
* Get an instance of Token from a given JSON
* @param {TokenJSON} data - The token data, as returned by CoreNLP API service
* @returns {Token} token - A new Token instance
*/
static fromJSON(data: TokenJSON): Token;
}
/**
* @namespace CoreNLP/simple/annotator
* @description Predefined annotators {@link https://stanfordnlp.github.io/CoreNLP/annotators.html}
*/
namespace annotator {
/**
* @class
* @classdesc Class representing an CorefAnnotator.
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, coref
* @see {@link https://stanfordnlp.github.io/CoreNLP/coref.html|CorefAnnotator}
*/
class CorefAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an DependencyParseAnnotator. Hydrates {@link Sentence.governors()}
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, lemma, ner, parse, depparse
* @see {@link https://stanfordnlp.github.io/CoreNLP/depparse.html|DependencyParseAnnotator}
*/
class DependencyParseAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an MorphaAnnotator. Hydrates {@link Token.lemma()}
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, lemma
* @see {@link https://stanfordnlp.github.io/CoreNLP/lemma.html|MorphaAnnotator}
*/
class MorphaAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an NERClassifierCombiner. Hydrates {@link Token.ner()}
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, lemma, ner
* @see {@link https://stanfordnlp.github.io/CoreNLP/ner.html|NERClassifierCombiner}
*/
class NERClassifierCombiner extends Annotator {
constructor(options?: any);
}
/**
* @class
* @class Class representing an ParserAnnotator. Hydrates {@link Token.parse()}
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, lemma, ner, parse
* @see {@link https://stanfordnlp.github.io/CoreNLP/parse.html|ParserAnnotator}
*/
class ParserAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an POSTaggerAnnotator. Hydrates {@link Token.pos()}
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos
* @see {@link https://stanfordnlp.github.io/CoreNLP/pos.html|POSTaggerAnnotator}
*/
class POSTaggerAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an RegexNERAnnotator.
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, regexner
* @see {@link https://stanfordnlp.github.io/CoreNLP/regexner.html|RegexNERAnnotator}
*/
class RegexNERAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an RelationExtractorAnnotator.
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit, pos, lemma, ner, depparse, relation
* @see {@link https://stanfordnlp.github.io/CoreNLP/relation.html|RelationExtractorAnnotator}
*/
class RelationExtractorAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an WordsToSentenceAnnotator.
* Combines multiple {@link Token}s into sentences
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize, ssplit
* @see {@link https://stanfordnlp.github.io/CoreNLP/ssplit.html|WordsToSentenceAnnotator}
*/
class WordsToSentenceAnnotator extends Annotator {
constructor(options?: any);
}
/**
* @class
* @classdesc Class representing an TokenizerAnnotator. Identifies {@link Token}s
* @extends Annotator
* @memberof CoreNLP/simple/annotator
* @requires tokenize
* @see {@link https://stanfordnlp.github.io/CoreNLP/tokenize.html|TokenizerAnnotator}
*/
class TokenizerAnnotator extends Annotator {
constructor(options?: any);
}
}
}
/**
* @namespace CoreNLP/util
* @description Utilities
*/
namespace util {
/**
* @class
* @classdesc Class representing a Parse tree structure
* @memberof CoreNLP/util
* @description
* The nodes are given in order left to right as the words in a sentence appears
* The leaves are grouped into semantic representations provided by the Annotator
* This class is pretty useful to use along with the ParserAnnotator
* @see inspired on {@link http://www.nltk.org/howto/tree.html|Tree}
* @see the lecture {@link http://www.cs.cornell.edu/courses/cs474/2004fa/lec1.pdf|Tree Syntax of Natural Language}
*/
class Tree {
constructor(node: Node);
/**
* Get a Tree string representation for debugging purposes
* @returns {string} tree
*/
dump(): string;
/**
* Performs Deep-first Search calling a visitor for each node
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitDeepFirst(): void;
/**
* Performs Deep-first Search calling a visitor for each node, from right to left
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitDeepFirstRight(): void;
/**
* Performs Deep-first Search calling a visitor only over leaves
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitLeaves(): void;
/**
* @param {Sentence} sentence
* @param {boolean} [doubleLink] whether the child nodes should have a reference
* to their parent or not - this allows the use of {@link Node.parent()}
* @returns {Tree} tree
*/
static fromSentence(sentence: CoreNLP.simple.Sentence, doubleLink?: boolean): Tree;
/**
* @param {string} str
* @param {boolean} [doubleLink] whether the child nodes should have a reference
* to their parent or not - this allows the use of {@link Node.parent()}
* @returns {Tree} tree
*/
static fromString(str: string, doubleLink?: boolean): Tree;
/**
* Get a Tree string representation for debugging purposes
* @returns {string} tree
*/
dump(): string;
/**
* Performs Deep-first Search calling a visitor for each node
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitDeepFirst(): void;
/**
* Performs Deep-first Search calling a visitor for each node, from right to left
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitDeepFirstRight(): void;
/**
* Performs Deep-first Search calling a visitor only over leaves
* @see {@link https://en.wikipedia.org/wiki/Depth-first_search|DFS}
*/
visitLeaves(): void;
/**
* @param {Sentence} sentence
* @param {boolean} [doubleLink] whether the child nodes should have a reference
* to their parent or not - this allows the use of {@link Node.parent()}
* @returns {Tree} tree
*/
static fromSentence(sentence: CoreNLP.simple.Sentence, doubleLink?: boolean): Tree;
/**
* @param {string} str
* @param {boolean} [doubleLink] whether the child nodes should have a reference
* to their parent or not - this allows the use of {@link Node.parent()}
* @returns {Tree} tree
*/
static fromString(str: string, doubleLink?: boolean): Tree;
}
}
}
export default CoreNLP;
/**
* @class
* @classdesc Class representing a Pipeline.
*/
export class Pipeline {
constructor(properties: Properties, language?: string, connector?: ConnectorServer | ConnectorCli);
/**
* Retrieves the current Service used by the pipeline
* @param {Service} service
*/
getService(service: Service): void;
/**
* Execute the pipeline against the annotable object, adding annotations to it.
* Calls the service and loads the associated response metadata into the Annotable model
* @async
* @param {Annotable} annotable - the document or sentence to be annotated
* @returns {Promise<Annotable>} annotated document / sentence
*/
annotate<T extends CoreNLP.simple.Annotable>(annotable: T): Promise<T>;
/**
* @param {Array.<Annotator>} requiredAnnotators
*/
assert(requiredAnnotators: CoreNLP.simple.Annotator[]): void;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a TokensRegex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the TokensRegex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateTokensRegex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a Semgrex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the Semgrex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateSemgrex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a Tregex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the Tregex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateTregex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
/**
* Retrieves the current Service used by the pipeline
* @param {Service} service
*/
getService(service: Service): void;
/**
* Execute the pipeline against the annotable object, adding annotations to it.
* Calls the service and loads the associated response metadata into the Annotable model
* @async
* @param {Annotable} annotable - the document or sentence to be annotated
* @returns {Promise<Annotable>} annotated document / sentence
*/
annotate(annotable: CoreNLP.simple.Annotable): Promise<CoreNLP.simple.Annotable>;
/**
* @param {Array.<Annotator>} requiredAnnotators
*/
assert(requiredAnnotators: CoreNLP.simple.Annotator[]): void;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a TokensRegex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the TokensRegex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateTokensRegex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a Semgrex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the Semgrex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateSemgrex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
/**
* Annotates the given Expression instance with matching groups and/or Tokens
* @param {Expression} expression - An annotable expression containing a Tregex pattern
* @param {boolean} [annotateExpression] - Whether to hydrate the annotations with tokens or not.
* IMPORTANT: The optional parameter 'annotateExpression' if true, will run the CoreNLP pipeline
* twice. First for the Tregex annotation, and one more for the standard pipeline
* Token annotations (pos, ner, lemma, etc).
* @returns {Expression} expression - The current expression instance
*/
annotateTregex(expression: CoreNLP.simple.Expression, annotateExpression?: boolean): CoreNLP.simple.Expression;
}
/**
* @class
* @classdesc Class representing a Properties set.
*/
export class Properties {
constructor(props: any);
/**
* Property setter
* @param {string} name - the property name
* @param {*} value - the property value
*/
setProperty(name: string, value: any): void;
/**
* Property getter
* @param {string} name - the property name
* @param {*} default - the defaut value to return if not set
* @returns {*} value - the property value
*/
getProperty(name: string, defaultValue: any): any;
/**
* Returns an Object map of the given properties
* @returns {Object} properties - the properties object
*/
getProperties(): any;
/**
* Returns a JSON object of the given properties
* @returns {Object} json - the properties object
*/
toJSON(): any;
/**
* Returns a properties file-like string of the given properties
* @returns {string} properties - the properties content
*/
toPropertiessFileContent(): string;
/**
* Property setter
* @param {string} name - the property name
* @param {*} value - the property value
*/
setProperty(name: string, value: any): void;
/**
* Property getter
* @param {string} name - the property name
* @param {*} default - the defaut value to return if not set
* @returns {*} value - the property value
*/
getProperty(name: string, defaultValue: any): any;
/**
* Returns an Object map of the given properties
* @returns {Object} properties - the properties object
*/
getProperties(): any;
/**
* Returns a JSON object of the given properties
* @returns {Object} json - the properties object
*/
toJSON(): any;
/**
* Returns a properties file-like string of the given properties
* @returns {string} properties - the properties content
*/
toPropertiessFileContent(): string;
}
/**
* @class
* @classdesc Middleware that interfaces between the pipeline and the connector strategies
*/
export class Service {
constructor(connector: ConnectorServer | ConnectorCli, language?: 'English' | 'French' | 'German' | 'Spanish' | 'Unspecified' | 'Whitesapce');
}
/**
* @class
* @classdesc Class representing an CorefChain
*/
export class CorefChain {
constructor(mentions: CorefMention[]);
/**
* Retrieves all the contained CorefMention instances
* @returns {Array.<CorefMention>} mentions
*/
mentions(): CorefMention[];
/**
* Retrieves a CorefMention at the index specified
* @param {number} index
* @returns {CorefMention} mention
*/
mention(index: number): CorefMention;
/**
* Retrieves the first representative mention
* @returns {CorefMention} mention
*/
representative(): CorefMention;
/**
* Retrieves all the non-representative mentions
* @returns {Array.<CorefMention>} mentions
*/
nonRepresentatives(): CorefMention[];
/**
* Gets or sets a Document reference for the current coref-chain
* @param {Document} doc
* @returns {Document} doc
*/
document(doc: CoreNLP.simple.Document): CoreNLP.simple.Document;
/**
* Update an instance of CorefChain with Document references to Sentence(s) and their Token(s)
* @param {Document} doc - a Document object, the same one used to generate corefs annotations
* @returns {CorefChain} chain - The current chain instance
*/
fromDocument(doc: CoreNLP.simple.Document): CorefChain;
/**
* Update an instance of CorefChain with data provided by a JSON
* @param {Array.<CorefMentionJSON>} data - A sentence corefs mentions chain, as
* returned by CoreNLP API service
* @returns {CorefChain} chain - The current chain instance
*/
fromJSON(data: CorefMentionJSON[]): CorefChain;
/**
* Get an instance of CorefChain from a given JSON of sentence corefs
* @param {Array.<CorefMentionJSON>} data - The sentence corefs data, as
* returned by CoreNLP API service
* @returns {CorefChain} sentenchain - A new CorefChain instance
*/
static fromJSON(data: CorefMentionJSON[]): CorefChain;
/**
* Retrieves all the contained CorefMention instances
* @returns {Array.<CorefMention>} mentions
*/
mentions(): CorefMention[];
/**
* Retrieves a CorefMention at the index specified
* @param {number} index
* @returns {CorefMention} mention
*/
mention(index: number): CorefMention;
/**
* Retrieves the first representative mention
* @returns {CorefMention} mention
*/
representative(): CorefMention;
/**
* Retrieves all the non-representative mentions
* @returns {Array.<CorefMention>} mentions
*/
nonRepresentatives(): CorefMention[];
/**
* Gets or sets a Document reference for the current coref-chain
* @param {Document} doc
* @returns {Document} doc
*/
document(doc: CoreNLP.simple.Document): CoreNLP.simple.Document;
/**
* Update an instance of CorefChain with Document references to Sentence(s) and their Token(s)
* @param {Document} doc - a Document object, the same one used to generate corefs annotations
* @returns {CorefChain} chain - The current chain instance
*/
fromDocument(doc: CoreNLP.simple.Document): CorefChain;
/**
* Update an instance of CorefChain with data provided by a JSON
* @param {Array.<CorefMentionJSON>} data - A sentence corefs mentions chain, as
* returned by CoreNLP API service
* @returns {CorefChain} chain - The current chain instance
*/
fromJSON(data: CorefMentionJSON[]): CorefChain;
/**
* Get an instance of CorefChain from a given JSON of sentence corefs
* @param {Array.<CorefMentionJSON>} data - The sentence corefs data, as
* returned by CoreNLP API service
* @returns {CorefChain} sentenchain - A new CorefChain instance
*/
static fromJSON(data: CorefMentionJSON[]): CorefChain;
}
/**
* A CorefMention.
* @typedef CorefMentionJSON
* @property {number} id - Mention ID
* @property {string} text - The text (literal word) of the mention
* @property {number} sentNum - 1-based index of the sentence containinng this mention
* @property {number} headIndex - 1-based index
* @property {number} startIndex - 1-based index
* @property {number} endIndex - 1-based index
* @property {boolean} isRepresentativeMention - Wehther the mention word is representative or not
* @property {("ANIMATE"|"INANIMATE"|"UNKNOWN")} animacy - Mention's animacy
* @property {("FEMALE"|"MALE"|"NEUTRAL"|"UNKNOWN")} gender - Gender of the mention
* @property {("SINGULAR"|"PLURAL"|"UNKNOWN")} number - Cardinality of the mention
* @property {("PRONOMINAL"|"NOMINAL"|"PROPER"|"LIST")} type - Mention type
* @property {Array} position - Position is a binary tuple of
* (sentence number, mention number in that sentence). This is used for indexing by mention.
*
* @see {@link https://github.com/stanfordnlp/CoreNLP/blob/7cfaf869f9500da16b858ab1a2835234ae46f96e/src/edu/stanford/nlp/dcoref/CorefChain.java#L148}
* @see {@link https://github.com/stanfordnlp/CoreNLP/blob/master/src/edu/stanford/nlp/dcoref/Dictionaries.java} for enum definitions
*/
export type CorefMentionJSON = {
id: number;
text: string;
sentNum: number;
headIndex: number;
startIndex: number;
endIndex: number;
isRepresentativeMention: boolean;
animacy: "ANIMATE" | "INANIMATE" | "UNKNOWN";
gender: "FEMALE" | "MALE" | "NEUTRAL" | "UNKNOWN";
number: "SINGULAR" | "PLURAL" | "UNKNOWN";
type: "PRONOMINAL" | "NOMINAL" | "PROPER" | "LIST";
position: number[];
};
/**
* @class
* @classdesc Class representing an CorefMention
*/
export class CorefMention {
/**
* Retrieves the mention ID
* @returns {string} id
*/
id(): string;
/**
* Retrieves the mention text
* @returns {string} text
*/
text(): string;
/**
* Retrieves the mention sentence number
* @see {@link CorefMention.sentence()} for simplicity
* @returns {number} sentNum
*/
sentNum(): number;
/**
* Retrieves the mention headIndex
* @returns {number} headIndex
*/
headIndex(): number;
/**
* Retrieves the mention startIndex
* @returns {number} startIndex
*/
startIndex(): number;
/**
* Retrieves the mention endIndex
* @returns {number} endIndex
*/
endIndex(): number;
/**
* Tells you if the mentions is representative or not
* @returns {boolean} isRepresentativeMention
*/
isRepresentativeMention(): boolean;
/**
* Retrieves the mention animacy
* @returns {("ANIMATE"|"INANIMATE"|"UNKNOWN")} animacy
*/
animacy(): "ANIMATE" | "INANIMATE" | "UNKNOWN";
/**
* Retrieves the mention gender
* @returns {("FEMALE"|"MALE"|"NEUTRAL"|"UNKNOWN")} gender
*/
gender(): "FEMALE" | "MALE" | "NEUTRAL" | "UNKNOWN";
/**
* Retrieves the mention number
* @returns {("SINGULAR"|"PLURAL"|"UNKNOWN")} number
*/
number(): "SINGULAR" | "PLURAL" | "UNKNOWN";
/**
* Retrieves the mention type
* @returns {("PRONOMINAL"|"NOMINAL"|"PROPER"|"LIST")} type
*/
type(): "PRONOMINAL" | "NOMINAL" | "PROPER" | "LIST";
/**
* Retrieves the mention's sentence container
* @returns {Sentence} sentence
*/
sentence(): CoreNLP.simple.Sentence;
/**
* Retrieves the mention's associated token
* @returns {Token} token
*/
token(): CoreNLP.simple.Token;
/**
* Update an instance of CorefMention with data provided by a JSON
* @param {CorefMentionJSON} data - The mention data, as returned by CoreNLP API service
* @returns {CorefMention} mention - The current mention instance
*/
fromJSON(data: CorefMentionJSON): CorefMention;
/**
* Get an instance of CorefMention from a given JSON
* @param {CorefMentionJSON} data - The match data, as returned by CoreNLP API service
* @returns {CorefMention} mention - A new CorefMention instance
*/
static fromJSON(data: CorefMentionJSON): CorefMention;
/**
* Retrieves the mention ID
* @returns {string} id
*/
id(): string;
/**
* Retrieves the mention text
* @returns {string} text
*/
text(): string;
/**
* Retrieves the mention sentence number
* @see {@link CorefMention.sentence()} for simplicity
* @returns {number} sentNum
*/
sentNum(): number;
/**
* Retrieves the mention headIndex
* @returns {number} headIndex
*/
headIndex(): number;
/**
* Retrieves the mention startIndex
* @returns {number} startIndex
*/
startIndex(): number;
/**
* Retrieves the mention endIndex
* @returns {number} endIndex
*/
endIndex(): number;
/**
* Tells you if the mentions is representative or not
* @returns {boolean} isRepresentativeMention
*/
isRepresentativeMention(): boolean;
/**
* Retrieves the mention animacy
* @returns {("ANIMATE"|"INANIMATE"|"UNKNOWN")} animacy
*/
animacy(): "ANIMATE" | "INANIMATE" | "UNKNOWN";
/**
* Retrieves the mention gender
* @returns {("FEMALE"|"MALE"|"NEUTRAL"|"UNKNOWN")} gender
*/
gender(): "FEMALE" | "MALE" | "NEUTRAL" | "UNKNOWN";
/**
* Retrieves the mention number
* @returns {("SINGULAR"|"PLURAL"|"UNKNOWN")} number
*/
number(): "SINGULAR" | "PLURAL" | "UNKNOWN";
/**
* Retrieves the mention type
* @returns {("PRONOMINAL"|"NOMINAL"|"PROPER"|"LIST")} type
*/
type(): "PRONOMINAL" | "NOMINAL" | "PROPER" | "LIST";
/**
* Retrieves the mention's sentence container
* @returns {Sentence} sentence
*/
sentence(): CoreNLP.simple.Sentence;
/**
* Retrieves the mention's associated token
* @returns {Token} token
*/
token(): CoreNLP.simple.Token;
/**
* Update an instance of CorefMention with data provided by a JSON
* @param {CorefMentionJSON} data - The mention data, as returned by CoreNLP API service
* @returns {CorefMention} mention - The current mention instance
*/
fromJSON(data: CorefMentionJSON): CorefMention;
/**
* Get an instance of CorefMention from a given JSON
* @param {CorefMentionJSON} data - The match data, as returned by CoreNLP API service
* @returns {CorefMention} mention - A new CorefMention instance
*/
static fromJSON(data: CorefMentionJSON): CorefMention;
}
/**
* The CoreNLP API JSON structure representing a document
* @typedef DocumentJSON
* @property {number} index
* @property {Array.<Sentence>} sentences
*/
declare type DocumentJSON = {
index: number;
sentences: CoreNLP.simple.Sentence[];
};
/**
* @typedef ExpressionSentenceMatchGroup
* @property {string} label - group label
* @property {number} begin - 0-based index of the matched group, relative to the given text
* @property {number} end - 0-based index of the matched group, relative to the given text
* @property {Token} [token] - onluy given if aggregated with an annotated Sentence or Document
* @property {ExpressionSentenceMatchGroup} [$label] - other groups inside
*/
declare type ExpressionSentenceMatchGroup = {
label: string;
begin: number;
end: number;
token?: CoreNLP.simple.Token;
$label?: ExpressionSentenceMatchGroup;
};
/**
* A ExpressionSentenceMatch of either 'TokensRegex', 'Semgrex' or 'Tregex'.
* @typedef ExpressionSentenceMatchJSON
* @property {number} begin - word begin position, starting from zero
* @property {number} end - word end position, starting from zero (no match ends at 0)
* @property {string} text - matched text
* @property {string} [$label] - any label, as defined in the expression pattern
*/
declare type ExpressionSentenceMatchJSON = {
begin: number;
end: number;
text: string;
$label?: string;
};
/**
* @class
* @classdesc Class representing an ExpressionSentenceMatch
*/
declare class ExpressionSentenceMatch {
/**
* Returns the main and labeled groups as a list of ExpressionSentenceMatchGroup
* @returns {Array.<ExpressionSentenceMatchGroup>} groups
*/
groups(): ExpressionSentenceMatchGroup[];
/**
* Returns the labeled group as ExpressionSentenceMatchGroup from a given label
* @description
* Nodes in a Macthed expression can be named, we call them groups here, and
* the labels are the name of the nodes.
* @see {@link https://nlp.stanford.edu/nlp/javadoc/javanlp/edu/stanford/nlp/semgraph/semgrex/SemgrexPattern.html#Naming_nodes}
* @param {string} label - The label name, not prefixed wih $
* @returns {ExpressionSentenceMatchGroup} group
*/
group(label: string): ExpressionSentenceMatchGroup;
/**
* Retrieves the list of labels (aliases) available for the current sentence match.
* @description
* Labels are those aliases you can add to a group match expression, for example,
* in Semgrex, you can do {ner:/PERSON/=good_guy}, from where "good_guy" would be the label
* and internally it will come as $good_guy as a member of {@link ExpressionSentenceMatchGroup}.
* @returns {Array.<string>} labels
*/
labels(): string[];
/**
* Update an instance of ExpressionSentenceMatch with data provided by a JSON
* @param {ExpressionSentenceMatchJSON} data - The match data, as returned by CoreNLP API service
* @returns {ExpressionSentenceMatch} expression - The current match instance
*/
fromJSON(data: ExpressionSentenceMatchJSON): ExpressionSentenceMatch;
/**
* Get an instance of ExpressionSentenceMatch from a given JSON
* @param {ExpressionSentenceMatchJSON} data - The match data, as returned by CoreNLP API service
* @returns {ExpressionSentenceMatch} match - A new ExpressionSentenceMatch instance
*/
static fromJSON(data: ExpressionSentenceMatchJSON): ExpressionSentenceMatch;
/**
* Returns the main and labeled groups as a list of ExpressionSentenceMatchGroup
* @returns {Array.<ExpressionSentenceMatchGroup>} groups
*/
groups(): ExpressionSentenceMatchGroup[];
/**
* Returns the labeled group as ExpressionSentenceMatchGroup from a given label
* @description
* Nodes in a Macthed expression can be named, we call them groups here, and
* the labels are the name of the nodes.
* @see {@link https://nlp.stanford.edu/nlp/javadoc/javanlp/edu/stanford/nlp/semgraph/semgrex/SemgrexPattern.html#Naming_nodes}
* @param {string} label - The label name, not prefixed wih $
* @returns {ExpressionSentenceMatchGroup} group
*/
group(label: string): ExpressionSentenceMatchGroup;
/**
* Retrieves the list of labels (aliases) available for the current sentence match.
* @description
* Labels are those aliases you can add to a group match expression, for example,
* in Semgrex, you can do {ner:/PERSON/=good_guy}, from where "good_guy" would be the label
* and internally it will come as $good_guy as a member of {@link ExpressionSentenceMatchGroup}.
* @returns {Array.<string>} labels
*/
labels(): string[];
/**
* Update an instance of ExpressionSentenceMatch with data provided by a JSON
* @param {ExpressionSentenceMatchJSON} data - The match data, as returned by CoreNLP API service
* @returns {ExpressionSentenceMatch} expression - The current match instance
*/
fromJSON(data: ExpressionSentenceMatchJSON): ExpressionSentenceMatch;
/**
* Get an instance of ExpressionSentenceMatch from a given JSON
* @param {ExpressionSentenceMatchJSON} data - The match data, as returned by CoreNLP API service
* @returns {ExpressionSentenceMatch} match - A new ExpressionSentenceMatch instance
*/
static fromJSON(data: ExpressionSentenceMatchJSON): ExpressionSentenceMatch;
}
declare type ExpressionSentenceJSON = { }
/**
* @class
* @classdesc Class representing an ExpressionSentence
*/
declare class ExpressionSentence {
constructor(matches: ExpressionSentenceMatch[]);
/**
* Retrieves all the contained ExpressionSentenceMatch instances
* @returns {Array.<ExpressionSentenceMatch>} matches
*/
matches(): ExpressionSentenceMatch[];
/**
* Retrieves a ExpressionSentenceMatch at the index specified
* @param {number} index
* @returns {ExpressionSentenceMatch} match
*/
match(index: number): ExpressionSentenceMatch;
/**
* Hydrates the current ExpressionSentence match groups with Token objects.
* @description
* The Expression / ExpressionSentence objects comes from outside the standard CoreNLP pipelines.
* This mean that neither 'TokensRegex', 'Semgrex' nor 'Tregex' will tag the nodes with POS,
* lemma, NER or any otehr annotation data. This is sometimes a usful resource to count with, if
* you can apart of getting the matching groups, get the annotated tokens for each word in the
* match group.
* @returns {ExpressionSentence} instance = The current instance
*/
mergeTokensFromSentence(): ExpressionSentence;
/**
* Update an instance of ExpressionSentence with data provided by a JSON
* @param {ExpressionSentenceJSON} data - The expression data, as returned by CoreNLP API service
* @returns {ExpressionSentenceJSON} sentence - The current sentence instance
*/
fromJSON(data: ExpressionSentenceJSON): ExpressionSentenceJSON;
/**
* Get an instance of ExpressionSentence from a given JSON of sentence matches
* @param {ExpressionSentenceJSON} data - The sentence data, as returned by CoreNLP API service
* @returns {ExpressionSentence} sentence - A new ExpressionSentence instance
*/
static fromJSON(data: ExpressionSentenceJSON): ExpressionSentence;
/**
* Retrieves all the contained ExpressionSentenceMatch instances
* @returns {Array.<ExpressionSentenceMatch>} matches
*/
matches(): ExpressionSentenceMatch[];
/**
* Retrieves a ExpressionSentenceMatch at the index specified
* @param {number} index
* @returns {ExpressionSentenceMatch} match
*/
match(index: number): ExpressionSentenceMatch;
/**
* Hydrates the current ExpressionSentence match groups with Token objects.
* @description
* The Expression / ExpressionSentence objects comes from outside the standard CoreNLP pipelines.
* This mean that neither 'TokensRegex', 'Semgrex' nor 'Tregex' will tag the nodes with POS,
* lemma, NER or any otehr annotation data. This is sometimes a usful resource to count with, if
* you can apart of getting the matching groups, get the annotated tokens for each word in the
* match group.
* @returns {ExpressionSentence} instance = The current instance
*/
mergeTokensFromSentence(): ExpressionSentence;
/**
* Update an instance of ExpressionSentence with data provided by a JSON
* @param {ExpressionSentenceJSON} data - The expression data, as returned by CoreNLP API service
* @returns {ExpressionSentenceJSON} sentence - The current sentence instance
*/
fromJSON(data: ExpressionSentenceJSON): ExpressionSentenceJSON;
/**
* Get an instance of ExpressionSentence from a given JSON of sentence matches
* @param {ExpressionSentenceJSON} data - The sentence data, as returned by CoreNLP API service
* @returns {ExpressionSentence} sentence - A new ExpressionSentence instance
*/
static fromJSON(data: ExpressionSentenceJSON): ExpressionSentence;
}
/**
* The CoreNLP API JSON structure representing an expression
* This expression structure can be found as the output of 'TokensRegex',
* 'Semgrex' and 'Tregex'.
* @typedef ExpressionJSON
* @property {number} index
* @property {Array.<Array.<ExpressionSentenceMatch>>} sentences
*/
declare type ExpressionJSON = {
index: number;
sentences: ExpressionSentenceMatch[][];
};
/**
* The CoreNLP API JSON structure representing a governor
* @typedef GovernorJSON
* @property {string} dep
* @property {number} governor
* @property {string} governorGloss
* @property {number} dependent
* @property {string} dependentGloss
*/
declare type GovernorJSON = {
dep: string;
governor: number;
governorGloss: string;
dependent: number;
dependentGloss: string;
};
/**
* The CoreNLP API JSON structure representing a sentence
* @typedef SentenceJSON
* @property {number} index - 1-based index, as they come indexed by StanfordCoreNLP
* @property {Array.<Token>} tokens
*/
declare type SentenceJSON = {
index: number;
tokens: CoreNLP.simple.Token[];
};
/**
* The CoreNLP API JSON structure representing a token
* @typedef TokenJSON
* @property {number} index
* @property {string} word
* @property {string} originalText
* @property {number} characterOffsetBegin
* @property {number} characterOffsetEnd
* @property {string} before
* @property {string} after
*/
declare type TokenJSON = {
index: number;
word: string;
originalText: string;
characterOffsetBegin: number;
characterOffsetEnd: number;
before: string;
after: string;
};
/**
* @typedef PosInfo
* @description
* PosInfo does not come as part of the CoreNLP. It is an indexed reference of POS tags
* by language provided by this library. It's only helpful for analysis and study. The
* data was collected from different documentation resources on the Web.
* The PosInfo may vary depending on the POS annotation types used, for example, CoreNLP
* for Spanish uses custom POS tags developed by Stanford, but this can also be changed
* to Universal Dependencies, which uses different tags.
* @property {string} group
* @property {string} tag
* @property {Array.<string>} examples
*/
declare type PosInfo = {
group: string;
tag: string;
examples: string[];
};
/**
* @class
* @classdesc Class representing a Sentence Tree Node
*/
declare class Node {
constructor();
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Retrieves the language ISO
* @return {string} text
*/
getLanguageISO(): string;
/**
* Sets the language ISO (given by the pipeline during the annotation process)
* This is solely to keep track of the language chosen for further analysis
* @return {string} text
*/
setLanguageISO(): string;
/**
* Retrieves the language ISO
* @return {string} text
*/
getLanguageISO(): string;
}
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent