Package language

import "google.golang.org/api/language/v1"
...
languageService, err := language.New(oauthHttpClient)

Constants

OAuth2 scopes used by this API.

const (
    // View and manage your data across Google Cloud Platform services
    CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
)

type AnalyzeEntitiesRequest ¶

AnalyzeEntitiesRequest: The entity analysis request message.

type AnalyzeEntitiesRequest struct {
    // Document: Input document.
    Document *Document `json:"document,omitempty"`

    // EncodingType: The encoding type used by the API to calculate offsets.
    //
    // Possible values:
    //   "NONE" - If `EncodingType` is not specified, encoding-dependent
    // information (such as
    // `begin_offset`) will be set at `-1`.
    //   "UTF8" - Encoding-dependent information (such as `begin_offset`) is
    // calculated based
    // on the UTF-8 encoding of the input. C++ and Go are examples of
    // languages
    // that use this encoding natively.
    //   "UTF16" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-16 encoding of the input. Java and Javascript are examples
    // of
    // languages that use this encoding natively.
    //   "UTF32" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-32 encoding of the input. Python is an example of a
    // language
    // that uses this encoding natively.
    EncodingType string `json:"encodingType,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Document") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Document") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeEntitiesRequest) MarshalJSON ¶

func (s *AnalyzeEntitiesRequest) MarshalJSON() ([]byte, error)

type AnalyzeEntitiesResponse ¶

AnalyzeEntitiesResponse: The entity analysis response message.

type AnalyzeEntitiesResponse struct {
    // Entities: The recognized entities in the input document.
    Entities []*Entity `json:"entities,omitempty"`

    // Language: The language of the text, which will be the same as the
    // language specified
    // in the request or, if not specified, the automatically-detected
    // language.
    // See Document.language field for more details.
    Language string `json:"language,omitempty"`

    // ServerResponse contains the HTTP response code and headers from the
    // server.
    googleapi.ServerResponse `json:"-"`

    // ForceSendFields is a list of field names (e.g. "Entities") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Entities") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeEntitiesResponse) MarshalJSON ¶

func (s *AnalyzeEntitiesResponse) MarshalJSON() ([]byte, error)

type AnalyzeSentimentRequest ¶

AnalyzeSentimentRequest: The sentiment analysis request message.

type AnalyzeSentimentRequest struct {
    // Document: Input document.
    Document *Document `json:"document,omitempty"`

    // EncodingType: The encoding type used by the API to calculate sentence
    // offsets.
    //
    // Possible values:
    //   "NONE" - If `EncodingType` is not specified, encoding-dependent
    // information (such as
    // `begin_offset`) will be set at `-1`.
    //   "UTF8" - Encoding-dependent information (such as `begin_offset`) is
    // calculated based
    // on the UTF-8 encoding of the input. C++ and Go are examples of
    // languages
    // that use this encoding natively.
    //   "UTF16" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-16 encoding of the input. Java and Javascript are examples
    // of
    // languages that use this encoding natively.
    //   "UTF32" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-32 encoding of the input. Python is an example of a
    // language
    // that uses this encoding natively.
    EncodingType string `json:"encodingType,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Document") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Document") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeSentimentRequest) MarshalJSON ¶

func (s *AnalyzeSentimentRequest) MarshalJSON() ([]byte, error)

type AnalyzeSentimentResponse ¶

AnalyzeSentimentResponse: The sentiment analysis response message.

type AnalyzeSentimentResponse struct {
    // DocumentSentiment: The overall sentiment of the input document.
    DocumentSentiment *Sentiment `json:"documentSentiment,omitempty"`

    // Language: The language of the text, which will be the same as the
    // language specified
    // in the request or, if not specified, the automatically-detected
    // language.
    // See Document.language field for more details.
    Language string `json:"language,omitempty"`

    // Sentences: The sentiment for all the sentences in the document.
    Sentences []*Sentence `json:"sentences,omitempty"`

    // ServerResponse contains the HTTP response code and headers from the
    // server.
    googleapi.ServerResponse `json:"-"`

    // ForceSendFields is a list of field names (e.g. "DocumentSentiment")
    // to unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "DocumentSentiment") to
    // include in API requests with the JSON null value. By default, fields
    // with empty values are omitted from API requests. However, any field
    // with an empty value appearing in NullFields will be sent to the
    // server as null. It is an error if a field in this list has a
    // non-empty value. This may be used to include null fields in Patch
    // requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeSentimentResponse) MarshalJSON ¶

func (s *AnalyzeSentimentResponse) MarshalJSON() ([]byte, error)

type AnalyzeSyntaxRequest ¶

AnalyzeSyntaxRequest: The syntax analysis request message.

type AnalyzeSyntaxRequest struct {
    // Document: Input document.
    Document *Document `json:"document,omitempty"`

    // EncodingType: The encoding type used by the API to calculate offsets.
    //
    // Possible values:
    //   "NONE" - If `EncodingType` is not specified, encoding-dependent
    // information (such as
    // `begin_offset`) will be set at `-1`.
    //   "UTF8" - Encoding-dependent information (such as `begin_offset`) is
    // calculated based
    // on the UTF-8 encoding of the input. C++ and Go are examples of
    // languages
    // that use this encoding natively.
    //   "UTF16" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-16 encoding of the input. Java and Javascript are examples
    // of
    // languages that use this encoding natively.
    //   "UTF32" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-32 encoding of the input. Python is an example of a
    // language
    // that uses this encoding natively.
    EncodingType string `json:"encodingType,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Document") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Document") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeSyntaxRequest) MarshalJSON ¶

func (s *AnalyzeSyntaxRequest) MarshalJSON() ([]byte, error)

type AnalyzeSyntaxResponse ¶

AnalyzeSyntaxResponse: The syntax analysis response message.

type AnalyzeSyntaxResponse struct {
    // Language: The language of the text, which will be the same as the
    // language specified
    // in the request or, if not specified, the automatically-detected
    // language.
    // See Document.language field for more details.
    Language string `json:"language,omitempty"`

    // Sentences: Sentences in the input document.
    Sentences []*Sentence `json:"sentences,omitempty"`

    // Tokens: Tokens, along with their syntactic information, in the input
    // document.
    Tokens []*Token `json:"tokens,omitempty"`

    // ServerResponse contains the HTTP response code and headers from the
    // server.
    googleapi.ServerResponse `json:"-"`

    // ForceSendFields is a list of field names (e.g. "Language") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Language") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnalyzeSyntaxResponse) MarshalJSON ¶

func (s *AnalyzeSyntaxResponse) MarshalJSON() ([]byte, error)

type AnnotateTextRequest ¶

AnnotateTextRequest: The request message for the text annotation API, which can perform multiple analysis types (sentiment, entities, and syntax) in one call.

type AnnotateTextRequest struct {
    // Document: Input document.
    Document *Document `json:"document,omitempty"`

    // EncodingType: The encoding type used by the API to calculate offsets.
    //
    // Possible values:
    //   "NONE" - If `EncodingType` is not specified, encoding-dependent
    // information (such as
    // `begin_offset`) will be set at `-1`.
    //   "UTF8" - Encoding-dependent information (such as `begin_offset`) is
    // calculated based
    // on the UTF-8 encoding of the input. C++ and Go are examples of
    // languages
    // that use this encoding natively.
    //   "UTF16" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-16 encoding of the input. Java and Javascript are examples
    // of
    // languages that use this encoding natively.
    //   "UTF32" - Encoding-dependent information (such as `begin_offset`)
    // is calculated based
    // on the UTF-32 encoding of the input. Python is an example of a
    // language
    // that uses this encoding natively.
    EncodingType string `json:"encodingType,omitempty"`

    // Features: The enabled features.
    Features *Features `json:"features,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Document") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Document") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*AnnotateTextRequest) MarshalJSON ¶

func (s *AnnotateTextRequest) MarshalJSON() ([]byte, error)

type AnnotateTextResponse ¶

AnnotateTextResponse: The text annotations response message.

type AnnotateTextResponse struct {
    // DocumentSentiment: The overall sentiment for the document. Populated
    // if the user
    // enables
    // AnnotateTextRequest.Features.extract_document_sentiment.
    DocumentSentiment *Sentiment `json:"documentSentiment,omitempty"`

    // Entities: Entities, along with their semantic information, in the
    // input document.
    // Populated if the user
    // enables
    // AnnotateTextRequest.Features.extract_entities.
    Entities []*Entity `json:"entities,omitempty"`

    // Language: The language of the text, which will be the same as the
    // language specified
    // in the request or, if not specified, the automatically-detected
    // language.
    // See Document.language field for more details.
    Language string `json:"language,omitempty"`

    // Sentences: Sentences in the input document. Populated if the user
    // enables
    // AnnotateTextRequest.Features.extract_syntax.
    Sentences []*Sentence `json:"sentences,omitempty"`

    // Tokens: Tokens, along with their syntactic information, in the input
    // document.
    // Populated if the user
    // enables
    // AnnotateTextRequest.Features.extract_syntax.
    Tokens []*Token `json:"tokens,omitempty"`

    // ServerResponse contains the HTTP response code and headers from the
    // server.
    googleapi.ServerResponse `json:"-"`

    // ForceSendFields is a list of field names (e.g. "DocumentSentiment")
    // to unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "DocumentSentiment") to
    // include in API requests with the JSON null value. By default, fields
    // with empty values are omitted from API requests. However, any field
    // with an empty value appearing in NullFields will be sent to the
    // server as null. It is an error if a field in this list has a
    // non-empty value. This may be used to include null fields in Patch
    // requests.
    NullFields []string `json:"-"`
}

func (*AnnotateTextResponse) MarshalJSON ¶

func (s *AnnotateTextResponse) MarshalJSON() ([]byte, error)

type DependencyEdge ¶

DependencyEdge: Represents dependency parse tree information for a token. (For more information on dependency labels, see http://www.aclweb.org/anthology/P13-2017

type DependencyEdge struct {
    // HeadTokenIndex: Represents the head of this token in the dependency
    // tree.
    // This is the index of the token which has an arc going to this
    // token.
    // The index is the position of the token in the array of tokens
    // returned
    // by the API method. If this token is a root token, then
    // the
    // `head_token_index` is its own index.
    HeadTokenIndex int64 `json:"headTokenIndex,omitempty"`

    // Label: The parse label for the token.
    //
    // Possible values:
    //   "UNKNOWN" - Unknown
    //   "ABBREV" - Abbreviation modifier
    //   "ACOMP" - Adjectival complement
    //   "ADVCL" - Adverbial clause modifier
    //   "ADVMOD" - Adverbial modifier
    //   "AMOD" - Adjectival modifier of an NP
    //   "APPOS" - Appositional modifier of an NP
    //   "ATTR" - Attribute dependent of a copular verb
    //   "AUX" - Auxiliary (non-main) verb
    //   "AUXPASS" - Passive auxiliary
    //   "CC" - Coordinating conjunction
    //   "CCOMP" - Clausal complement of a verb or adjective
    //   "CONJ" - Conjunct
    //   "CSUBJ" - Clausal subject
    //   "CSUBJPASS" - Clausal passive subject
    //   "DEP" - Dependency (unable to determine)
    //   "DET" - Determiner
    //   "DISCOURSE" - Discourse
    //   "DOBJ" - Direct object
    //   "EXPL" - Expletive
    //   "GOESWITH" - Goes with (part of a word in a text not well edited)
    //   "IOBJ" - Indirect object
    //   "MARK" - Marker (word introducing a subordinate clause)
    //   "MWE" - Multi-word expression
    //   "MWV" - Multi-word verbal expression
    //   "NEG" - Negation modifier
    //   "NN" - Noun compound modifier
    //   "NPADVMOD" - Noun phrase used as an adverbial modifier
    //   "NSUBJ" - Nominal subject
    //   "NSUBJPASS" - Passive nominal subject
    //   "NUM" - Numeric modifier of a noun
    //   "NUMBER" - Element of compound number
    //   "P" - Punctuation mark
    //   "PARATAXIS" - Parataxis relation
    //   "PARTMOD" - Participial modifier
    //   "PCOMP" - The complement of a preposition is a clause
    //   "POBJ" - Object of a preposition
    //   "POSS" - Possession modifier
    //   "POSTNEG" - Postverbal negative particle
    //   "PRECOMP" - Predicate complement
    //   "PRECONJ" - Preconjunt
    //   "PREDET" - Predeterminer
    //   "PREF" - Prefix
    //   "PREP" - Prepositional modifier
    //   "PRONL" - The relationship between a verb and verbal morpheme
    //   "PRT" - Particle
    //   "PS" - Associative or possessive marker
    //   "QUANTMOD" - Quantifier phrase modifier
    //   "RCMOD" - Relative clause modifier
    //   "RCMODREL" - Complementizer in relative clause
    //   "RDROP" - Ellipsis without a preceding predicate
    //   "REF" - Referent
    //   "REMNANT" - Remnant
    //   "REPARANDUM" - Reparandum
    //   "ROOT" - Root
    //   "SNUM" - Suffix specifying a unit of number
    //   "SUFF" - Suffix
    //   "TMOD" - Temporal modifier
    //   "TOPIC" - Topic marker
    //   "VMOD" - Clause headed by an infinite form of the verb that
    // modifies a noun
    //   "VOCATIVE" - Vocative
    //   "XCOMP" - Open clausal complement
    //   "SUFFIX" - Name suffix
    //   "TITLE" - Name title
    //   "ADVPHMOD" - Adverbial phrase modifier
    //   "AUXCAUS" - Causative auxiliary
    //   "AUXVV" - Helper auxiliary
    //   "DTMOD" - Rentaishi (Prenominal modifier)
    //   "FOREIGN" - Foreign words
    //   "KW" - Keyword
    //   "LIST" - List for chains of comparable items
    //   "NOMC" - Nominalized clause
    //   "NOMCSUBJ" - Nominalized clausal subject
    //   "NOMCSUBJPASS" - Nominalized clausal passive
    //   "NUMC" - Compound of numeric modifier
    //   "COP" - Copula
    //   "DISLOCATED" - Dislocated relation (for fronted/topicalized
    // elements)
    Label string `json:"label,omitempty"`

    // ForceSendFields is a list of field names (e.g. "HeadTokenIndex") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "HeadTokenIndex") to
    // include in API requests with the JSON null value. By default, fields
    // with empty values are omitted from API requests. However, any field
    // with an empty value appearing in NullFields will be sent to the
    // server as null. It is an error if a field in this list has a
    // non-empty value. This may be used to include null fields in Patch
    // requests.
    NullFields []string `json:"-"`
}

func (*DependencyEdge) MarshalJSON ¶

func (s *DependencyEdge) MarshalJSON() ([]byte, error)

type Document ¶

Document: ################################################################ #

Represents the input to API methods.

type Document struct {
    // Content: The content of the input in string format.
    Content string `json:"content,omitempty"`

    // GcsContentUri: The Google Cloud Storage URI where the file content is
    // located.
    // This URI must be of the form: gs://bucket_name/object_name. For
    // more
    // details, see
    // https://cloud.google.com/storage/docs/reference-uris.
    // NOTE: Cloud Storage object versioning is not supported.
    GcsContentUri string `json:"gcsContentUri,omitempty"`

    // Language: The language of the document (if not specified, the
    // language is
    // automatically detected). Both ISO and BCP-47 language codes
    // are
    // accepted.<br>
    // [Language Support](/natural-language/docs/languages)
    // lists currently supported languages for each API method.
    // If the language (either specified by the caller or automatically
    // detected)
    // is not supported by the called API method, an `INVALID_ARGUMENT`
    // error
    // is returned.
    Language string `json:"language,omitempty"`

    // Type: Required. If the type is not set or is
    // `TYPE_UNSPECIFIED`,
    // returns an `INVALID_ARGUMENT` error.
    //
    // Possible values:
    //   "TYPE_UNSPECIFIED" - The content type is not specified.
    //   "PLAIN_TEXT" - Plain text
    //   "HTML" - HTML
    Type string `json:"type,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Content") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Content") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*Document) MarshalJSON ¶

func (s *Document) MarshalJSON() ([]byte, error)

type DocumentsAnalyzeEntitiesCall ¶

type DocumentsAnalyzeEntitiesCall struct {
    // contains filtered or unexported fields
}

func (*DocumentsAnalyzeEntitiesCall) Context ¶

func (c *DocumentsAnalyzeEntitiesCall) Context(ctx context.Context) *DocumentsAnalyzeEntitiesCall

Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

func (*DocumentsAnalyzeEntitiesCall) Do ¶

func (c *DocumentsAnalyzeEntitiesCall) Do(opts ...googleapi.CallOption) (*AnalyzeEntitiesResponse, error)

Do executes the "language.documents.analyzeEntities" call. Exactly one of *AnalyzeEntitiesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnalyzeEntitiesResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

func (*DocumentsAnalyzeEntitiesCall) Fields ¶

func (c *DocumentsAnalyzeEntitiesCall) Fields(s ...googleapi.Field) *DocumentsAnalyzeEntitiesCall

Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

func (*DocumentsAnalyzeEntitiesCall) Header ¶

func (c *DocumentsAnalyzeEntitiesCall) Header() http.Header

Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

type DocumentsAnalyzeSentimentCall ¶

type DocumentsAnalyzeSentimentCall struct {
    // contains filtered or unexported fields
}

func (*DocumentsAnalyzeSentimentCall) Context ¶

func (c *DocumentsAnalyzeSentimentCall) Context(ctx context.Context) *DocumentsAnalyzeSentimentCall

Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

func (*DocumentsAnalyzeSentimentCall) Do ¶

func (c *DocumentsAnalyzeSentimentCall) Do(opts ...googleapi.CallOption) (*AnalyzeSentimentResponse, error)

Do executes the "language.documents.analyzeSentiment" call. Exactly one of *AnalyzeSentimentResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnalyzeSentimentResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

func (*DocumentsAnalyzeSentimentCall) Fields ¶

func (c *DocumentsAnalyzeSentimentCall) Fields(s ...googleapi.Field) *DocumentsAnalyzeSentimentCall

Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

func (*DocumentsAnalyzeSentimentCall) Header ¶

func (c *DocumentsAnalyzeSentimentCall) Header() http.Header

Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

type DocumentsAnalyzeSyntaxCall ¶

type DocumentsAnalyzeSyntaxCall struct {
    // contains filtered or unexported fields
}

func (*DocumentsAnalyzeSyntaxCall) Context ¶

func (c *DocumentsAnalyzeSyntaxCall) Context(ctx context.Context) *DocumentsAnalyzeSyntaxCall

Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

func (*DocumentsAnalyzeSyntaxCall) Do ¶

func (c *DocumentsAnalyzeSyntaxCall) Do(opts ...googleapi.CallOption) (*AnalyzeSyntaxResponse, error)

Do executes the "language.documents.analyzeSyntax" call. Exactly one of *AnalyzeSyntaxResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnalyzeSyntaxResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

func (*DocumentsAnalyzeSyntaxCall) Fields ¶

func (c *DocumentsAnalyzeSyntaxCall) Fields(s ...googleapi.Field) *DocumentsAnalyzeSyntaxCall

Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

func (*DocumentsAnalyzeSyntaxCall) Header ¶

func (c *DocumentsAnalyzeSyntaxCall) Header() http.Header

Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

type DocumentsAnnotateTextCall ¶

type DocumentsAnnotateTextCall struct {
    // contains filtered or unexported fields
}

func (*DocumentsAnnotateTextCall) Context ¶

func (c *DocumentsAnnotateTextCall) Context(ctx context.Context) *DocumentsAnnotateTextCall

Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

func (*DocumentsAnnotateTextCall) Do ¶

func (c *DocumentsAnnotateTextCall) Do(opts ...googleapi.CallOption) (*AnnotateTextResponse, error)

Do executes the "language.documents.annotateText" call. Exactly one of *AnnotateTextResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnnotateTextResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

func (*DocumentsAnnotateTextCall) Fields ¶

func (c *DocumentsAnnotateTextCall) Fields(s ...googleapi.Field) *DocumentsAnnotateTextCall

Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

func (*DocumentsAnnotateTextCall) Header ¶

func (c *DocumentsAnnotateTextCall) Header() http.Header

Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

type DocumentsService ¶

type DocumentsService struct {
    // contains filtered or unexported fields
}

func NewDocumentsService ¶

func NewDocumentsService(s *Service) *DocumentsService

func (*DocumentsService) AnalyzeEntities ¶

func (r *DocumentsService) AnalyzeEntities(analyzeentitiesrequest *AnalyzeEntitiesRequest) *DocumentsAnalyzeEntitiesCall

AnalyzeEntities: Finds named entities (currently proper names and common nouns) in the text along with entity types, salience, mentions for each entity, and other properties.

func (*DocumentsService) AnalyzeSentiment ¶

func (r *DocumentsService) AnalyzeSentiment(analyzesentimentrequest *AnalyzeSentimentRequest) *DocumentsAnalyzeSentimentCall

AnalyzeSentiment: Analyzes the sentiment of the provided text.

func (*DocumentsService) AnalyzeSyntax ¶

func (r *DocumentsService) AnalyzeSyntax(analyzesyntaxrequest *AnalyzeSyntaxRequest) *DocumentsAnalyzeSyntaxCall

AnalyzeSyntax: Analyzes the syntax of the text and provides sentence boundaries and tokenization along with part of speech tags, dependency trees, and other properties.

func (*DocumentsService) AnnotateText ¶

func (r *DocumentsService) AnnotateText(annotatetextrequest *AnnotateTextRequest) *DocumentsAnnotateTextCall

AnnotateText: A convenience method that provides all the features that analyzeSentiment, analyzeEntities, and analyzeSyntax provide in one call.

type Entity ¶

Entity: Represents a phrase in the text that is a known entity, such as a person, an organization, or location. The API associates information, such as salience and mentions, with entities.

type Entity struct {
    // Mentions: The mentions of this entity in the input document. The API
    // currently
    // supports proper noun mentions.
    Mentions []*EntityMention `json:"mentions,omitempty"`

    // Metadata: Metadata associated with the entity.
    //
    // Currently, Wikipedia URLs and Knowledge Graph MIDs are provided,
    // if
    // available. The associated keys are "wikipedia_url" and "mid",
    // respectively.
    Metadata map[string]string `json:"metadata,omitempty"`

    // Name: The representative name for the entity.
    Name string `json:"name,omitempty"`

    // Salience: The salience score associated with the entity in the [0,
    // 1.0] range.
    //
    // The salience score for an entity provides information about
    // the
    // importance or centrality of that entity to the entire document
    // text.
    // Scores closer to 0 are less salient, while scores closer to 1.0 are
    // highly
    // salient.
    Salience float64 `json:"salience,omitempty"`

    // Type: The entity type.
    //
    // Possible values:
    //   "UNKNOWN" - Unknown
    //   "PERSON" - Person
    //   "LOCATION" - Location
    //   "ORGANIZATION" - Organization
    //   "EVENT" - Event
    //   "WORK_OF_ART" - Work of art
    //   "CONSUMER_GOOD" - Consumer goods
    //   "OTHER" - Other types
    Type string `json:"type,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Mentions") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Mentions") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*Entity) MarshalJSON ¶

func (s *Entity) MarshalJSON() ([]byte, error)

func (*Entity) UnmarshalJSON ¶

func (s *Entity) UnmarshalJSON(data []byte) error

type EntityMention ¶

EntityMention: Represents a mention for an entity in the text. Currently, proper noun mentions are supported.

type EntityMention struct {
    // Text: The mention text.
    Text *TextSpan `json:"text,omitempty"`

    // Type: The type of the entity mention.
    //
    // Possible values:
    //   "TYPE_UNKNOWN" - Unknown
    //   "PROPER" - Proper name
    //   "COMMON" - Common noun (or noun compound)
    Type string `json:"type,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Text") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Text") to include in API
    // requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*EntityMention) MarshalJSON ¶

func (s *EntityMention) MarshalJSON() ([]byte, error)

type Features ¶

Features: All available features for sentiment, syntax, and semantic analysis. Setting each one to true will enable that specific analysis for the input.

type Features struct {
    // ExtractDocumentSentiment: Extract document-level sentiment.
    ExtractDocumentSentiment bool `json:"extractDocumentSentiment,omitempty"`

    // ExtractEntities: Extract entities.
    ExtractEntities bool `json:"extractEntities,omitempty"`

    // ExtractSyntax: Extract syntax information.
    ExtractSyntax bool `json:"extractSyntax,omitempty"`

    // ForceSendFields is a list of field names (e.g.
    // "ExtractDocumentSentiment") to unconditionally include in API
    // requests. By default, fields with empty values are omitted from API
    // requests. However, any non-pointer, non-interface field appearing in
    // ForceSendFields will be sent to the server regardless of whether the
    // field is empty or not. This may be used to include empty fields in
    // Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "ExtractDocumentSentiment")
    // to include in API requests with the JSON null value. By default,
    // fields with empty values are omitted from API requests. However, any
    // field with an empty value appearing in NullFields will be sent to the
    // server as null. It is an error if a field in this list has a
    // non-empty value. This may be used to include null fields in Patch
    // requests.
    NullFields []string `json:"-"`
}

func (*Features) MarshalJSON ¶

func (s *Features) MarshalJSON() ([]byte, error)

type PartOfSpeech ¶

PartOfSpeech: Represents part of speech information for a token. Parts of speech are as defined in http://www.lrec-conf.org/proceedings/lrec2012/pdf/274_Paper.pdf

type PartOfSpeech struct {
    // Aspect: The grammatical aspect.
    //
    // Possible values:
    //   "ASPECT_UNKNOWN" - Aspect is not applicable in the analyzed
    // language or is not predicted.
    //   "PERFECTIVE" - Perfective
    //   "IMPERFECTIVE" - Imperfective
    //   "PROGRESSIVE" - Progressive
    Aspect string `json:"aspect,omitempty"`

    // Case: The grammatical case.
    //
    // Possible values:
    //   "CASE_UNKNOWN" - Case is not applicable in the analyzed language or
    // is not predicted.
    //   "ACCUSATIVE" - Accusative
    //   "ADVERBIAL" - Adverbial
    //   "COMPLEMENTIVE" - Complementive
    //   "DATIVE" - Dative
    //   "GENITIVE" - Genitive
    //   "INSTRUMENTAL" - Instrumental
    //   "LOCATIVE" - Locative
    //   "NOMINATIVE" - Nominative
    //   "OBLIQUE" - Oblique
    //   "PARTITIVE" - Partitive
    //   "PREPOSITIONAL" - Prepositional
    //   "REFLEXIVE_CASE" - Reflexive
    //   "RELATIVE_CASE" - Relative
    //   "VOCATIVE" - Vocative
    Case string `json:"case,omitempty"`

    // Form: The grammatical form.
    //
    // Possible values:
    //   "FORM_UNKNOWN" - Form is not applicable in the analyzed language or
    // is not predicted.
    //   "ADNOMIAL" - Adnomial
    //   "AUXILIARY" - Auxiliary
    //   "COMPLEMENTIZER" - Complementizer
    //   "FINAL_ENDING" - Final ending
    //   "GERUND" - Gerund
    //   "REALIS" - Realis
    //   "IRREALIS" - Irrealis
    //   "SHORT" - Short form
    //   "LONG" - Long form
    //   "ORDER" - Order form
    //   "SPECIFIC" - Specific form
    Form string `json:"form,omitempty"`

    // Gender: The grammatical gender.
    //
    // Possible values:
    //   "GENDER_UNKNOWN" - Gender is not applicable in the analyzed
    // language or is not predicted.
    //   "FEMININE" - Feminine
    //   "MASCULINE" - Masculine
    //   "NEUTER" - Neuter
    Gender string `json:"gender,omitempty"`

    // Mood: The grammatical mood.
    //
    // Possible values:
    //   "MOOD_UNKNOWN" - Mood is not applicable in the analyzed language or
    // is not predicted.
    //   "CONDITIONAL_MOOD" - Conditional
    //   "IMPERATIVE" - Imperative
    //   "INDICATIVE" - Indicative
    //   "INTERROGATIVE" - Interrogative
    //   "JUSSIVE" - Jussive
    //   "SUBJUNCTIVE" - Subjunctive
    Mood string `json:"mood,omitempty"`

    // Number: The grammatical number.
    //
    // Possible values:
    //   "NUMBER_UNKNOWN" - Number is not applicable in the analyzed
    // language or is not predicted.
    //   "SINGULAR" - Singular
    //   "PLURAL" - Plural
    //   "DUAL" - Dual
    Number string `json:"number,omitempty"`

    // Person: The grammatical person.
    //
    // Possible values:
    //   "PERSON_UNKNOWN" - Person is not applicable in the analyzed
    // language or is not predicted.
    //   "FIRST" - First
    //   "SECOND" - Second
    //   "THIRD" - Third
    //   "REFLEXIVE_PERSON" - Reflexive
    Person string `json:"person,omitempty"`

    // Proper: The grammatical properness.
    //
    // Possible values:
    //   "PROPER_UNKNOWN" - Proper is not applicable in the analyzed
    // language or is not predicted.
    //   "PROPER" - Proper
    //   "NOT_PROPER" - Not proper
    Proper string `json:"proper,omitempty"`

    // Reciprocity: The grammatical reciprocity.
    //
    // Possible values:
    //   "RECIPROCITY_UNKNOWN" - Reciprocity is not applicable in the
    // analyzed language or is not
    // predicted.
    //   "RECIPROCAL" - Reciprocal
    //   "NON_RECIPROCAL" - Non-reciprocal
    Reciprocity string `json:"reciprocity,omitempty"`

    // Tag: The part of speech tag.
    //
    // Possible values:
    //   "UNKNOWN" - Unknown
    //   "ADJ" - Adjective
    //   "ADP" - Adposition (preposition and postposition)
    //   "ADV" - Adverb
    //   "CONJ" - Conjunction
    //   "DET" - Determiner
    //   "NOUN" - Noun (common and proper)
    //   "NUM" - Cardinal number
    //   "PRON" - Pronoun
    //   "PRT" - Particle or other function word
    //   "PUNCT" - Punctuation
    //   "VERB" - Verb (all tenses and modes)
    //   "X" - Other: foreign words, typos, abbreviations
    //   "AFFIX" - Affix
    Tag string `json:"tag,omitempty"`

    // Tense: The grammatical tense.
    //
    // Possible values:
    //   "TENSE_UNKNOWN" - Tense is not applicable in the analyzed language
    // or is not predicted.
    //   "CONDITIONAL_TENSE" - Conditional
    //   "FUTURE" - Future
    //   "PAST" - Past
    //   "PRESENT" - Present
    //   "IMPERFECT" - Imperfect
    //   "PLUPERFECT" - Pluperfect
    Tense string `json:"tense,omitempty"`

    // Voice: The grammatical voice.
    //
    // Possible values:
    //   "VOICE_UNKNOWN" - Voice is not applicable in the analyzed language
    // or is not predicted.
    //   "ACTIVE" - Active
    //   "CAUSATIVE" - Causative
    //   "PASSIVE" - Passive
    Voice string `json:"voice,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Aspect") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Aspect") to include in API
    // requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*PartOfSpeech) MarshalJSON ¶

func (s *PartOfSpeech) MarshalJSON() ([]byte, error)

type Sentence ¶

Sentence: Represents a sentence in the input document.

type Sentence struct {
    // Sentiment: For calls to AnalyzeSentiment or
    // if
    // AnnotateTextRequest.Features.extract_document_sentiment is set
    // to
    // true, this field will contain the sentiment for the sentence.
    Sentiment *Sentiment `json:"sentiment,omitempty"`

    // Text: The sentence text.
    Text *TextSpan `json:"text,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Sentiment") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Sentiment") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*Sentence) MarshalJSON ¶

func (s *Sentence) MarshalJSON() ([]byte, error)

type Sentiment ¶

Sentiment: Represents the feeling associated with the entire text or entities in the text.

type Sentiment struct {
    // Magnitude: A non-negative number in the [0, +inf) range, which
    // represents
    // the absolute magnitude of sentiment regardless of score (positive
    // or
    // negative).
    Magnitude float64 `json:"magnitude,omitempty"`

    // Score: Sentiment score between -1.0 (negative sentiment) and
    // 1.0
    // (positive sentiment).
    Score float64 `json:"score,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Magnitude") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Magnitude") to include in
    // API requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*Sentiment) MarshalJSON ¶

func (s *Sentiment) MarshalJSON() ([]byte, error)

func (*Sentiment) UnmarshalJSON ¶

func (s *Sentiment) UnmarshalJSON(data []byte) error

type Service ¶

type Service struct {
    BasePath  string // API endpoint base URL
    UserAgent string // optional additional User-Agent fragment

    Documents *DocumentsService
    // contains filtered or unexported fields
}

func New ¶

func New(client *http.Client) (*Service, error)

type Status ¶

Status: The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). The error model is designed to be:

- Simple to use and understand for most users - Flexible enough to meet unexpected needs

# Overview

The `Status` message contains three pieces of data: error code, error message, and error details. The error code should be an enum value of google.rpc.Code, but it may accept additional error codes if needed. The error message should be a developer-facing English message that helps developers *understand* and *resolve* the error. If a localized user-facing error message is needed, put the localized message in the error details or localize it in the client. The optional error details may contain arbitrary information about the error. There is a predefined set of error detail types in the package `google.rpc` that can be used for common error conditions.

# Language mapping

The `Status` message is the logical representation of the error model, but it is not necessarily the actual wire format. When the `Status` message is exposed in different client libraries and different wire protocols, it can be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped to some error codes in C.

# Other uses

The error model and the `Status` message can be used in a variety of environments, either with or without APIs, to provide a consistent developer experience across different environments.

Example uses of this error model include:

- Partial errors. If a service needs to return partial errors to the client,

it may embed the `Status` in the normal response to indicate the

partial

errors.

- Workflow errors. A typical workflow has multiple steps. Each step may

have a `Status` message for error reporting.

- Batch operations. If a client uses batch request and batch response, the

`Status` message should be used directly inside batch response,

one for

each error sub-response.

- Asynchronous operations. If an API call embeds asynchronous operation

results in its response, the status of those operations should

be

represented directly using the `Status` message.

- Logging. If some API errors are stored in logs, the message `Status` could

be used directly after any stripping needed for security/privacy

reasons.

type Status struct {
    // Code: The status code, which should be an enum value of
    // google.rpc.Code.
    Code int64 `json:"code,omitempty"`

    // Details: A list of messages that carry the error details.  There will
    // be a
    // common set of message types for APIs to use.
    Details []googleapi.RawMessage `json:"details,omitempty"`

    // Message: A developer-facing error message, which should be in
    // English. Any
    // user-facing error message should be localized and sent in
    // the
    // google.rpc.Status.details field, or localized by the client.
    Message string `json:"message,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Code") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "Code") to include in API
    // requests with the JSON null value. By default, fields with empty
    // values are omitted from API requests. However, any field with an
    // empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*Status) MarshalJSON ¶

func (s *Status) MarshalJSON() ([]byte, error)

type TextSpan ¶

TextSpan: Represents an output piece of text.

type TextSpan struct {
    // BeginOffset: The API calculates the beginning offset of the content
    // in the original
    // document according to the EncodingType specified in the API request.
    BeginOffset int64 `json:"beginOffset,omitempty"`

    // Content: The content of the output text.
    Content string `json:"content,omitempty"`

    // ForceSendFields is a list of field names (e.g. "BeginOffset") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "BeginOffset") to include
    // in API requests with the JSON null value. By default, fields with
    // empty values are omitted from API requests. However, any field with
    // an empty value appearing in NullFields will be sent to the server as
    // null. It is an error if a field in this list has a non-empty value.
    // This may be used to include null fields in Patch requests.
    NullFields []string `json:"-"`
}

func (*TextSpan) MarshalJSON ¶

func (s *TextSpan) MarshalJSON() ([]byte, error)

type Token ¶

Token: Represents the smallest syntactic building block of the text.

type Token struct {
    // DependencyEdge: Dependency tree parse for this token.
    DependencyEdge *DependencyEdge `json:"dependencyEdge,omitempty"`

    // Lemma: [Lemma](https://en.wikipedia.org/wiki/Lemma_%28morphology%29)
    // of the token.
    Lemma string `json:"lemma,omitempty"`

    // PartOfSpeech: Parts of speech tag for this token.
    PartOfSpeech *PartOfSpeech `json:"partOfSpeech,omitempty"`

    // Text: The token text.
    Text *TextSpan `json:"text,omitempty"`

    // ForceSendFields is a list of field names (e.g. "DependencyEdge") to
    // unconditionally include in API requests. By default, fields with
    // empty values are omitted from API requests. However, any non-pointer,
    // non-interface field appearing in ForceSendFields will be sent to the
    // server regardless of whether the field is empty or not. This may be
    // used to include empty fields in Patch requests.
    ForceSendFields []string `json:"-"`

    // NullFields is a list of field names (e.g. "DependencyEdge") to
    // include in API requests with the JSON null value. By default, fields
    // with empty values are omitted from API requests. However, any field
    // with an empty value appearing in NullFields will be sent to the
    // server as null. It is an error if a field in this list has a
    // non-empty value. This may be used to include null fields in Patch
    // requests.
    NullFields []string `json:"-"`
}

func (*Token) MarshalJSON ¶

func (s *Token) MarshalJSON() ([]byte, error)