api: google.golang.org/api/language/v1beta2 Index | Files

package language

import "google.golang.org/api/language/v1beta2"

Package language provides access to the Cloud Natural Language API.

This package is DEPRECATED. Use package cloud.google.com/go/language/apiv1 instead.

For product documentation, see: https://cloud.google.com/natural-language/

Creating a client

Usage example:

import "google.golang.org/api/language/v1beta2"
...
ctx := context.Background()
languageService, err := language.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:

languageService, err := language.NewService(ctx, option.WithScopes(language.CloudPlatformScope))

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:

languageService, err := language.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
languageService, err := language.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Package Files

language-gen.go

Constants

const (
    // Apply machine learning models to reveal the structure and meaning of
    // text
    CloudLanguageScope = "https://www.googleapis.com/auth/cloud-language"

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

OAuth2 scopes used by this API.

type AnalyzeEntitiesRequest Uses

type AnalyzeEntitiesRequest struct {
    // Document: Required. 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:"-"`
}

AnalyzeEntitiesRequest: The entity analysis request message.

func (*AnalyzeEntitiesRequest) MarshalJSON Uses

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

type AnalyzeEntitiesResponse Uses

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:"-"`
}

AnalyzeEntitiesResponse: The entity analysis response message.

func (*AnalyzeEntitiesResponse) MarshalJSON Uses

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

type AnalyzeEntitySentimentRequest Uses

type AnalyzeEntitySentimentRequest struct {
    // Document: Required. 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:"-"`
}

AnalyzeEntitySentimentRequest: The entity-level sentiment analysis request message.

func (*AnalyzeEntitySentimentRequest) MarshalJSON Uses

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

type AnalyzeEntitySentimentResponse Uses

type AnalyzeEntitySentimentResponse struct {
    // Entities: The recognized entities in the input document with
    // associated sentiments.
    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:"-"`
}

AnalyzeEntitySentimentResponse: The entity-level sentiment analysis response message.

func (*AnalyzeEntitySentimentResponse) MarshalJSON Uses

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

type AnalyzeSentimentRequest Uses

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

    // EncodingType: The encoding type used by the API to calculate sentence
    // offsets for the
    // sentence sentiment.
    //
    // 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:"-"`
}

AnalyzeSentimentRequest: The sentiment analysis request message.

func (*AnalyzeSentimentRequest) MarshalJSON Uses

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

type AnalyzeSentimentResponse Uses

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:"-"`
}

AnalyzeSentimentResponse: The sentiment analysis response message.

func (*AnalyzeSentimentResponse) MarshalJSON Uses

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

type AnalyzeSyntaxRequest Uses

type AnalyzeSyntaxRequest struct {
    // Document: Required. 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:"-"`
}

AnalyzeSyntaxRequest: The syntax analysis request message.

func (*AnalyzeSyntaxRequest) MarshalJSON Uses

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

type AnalyzeSyntaxResponse Uses

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:"-"`
}

AnalyzeSyntaxResponse: The syntax analysis response message.

func (*AnalyzeSyntaxResponse) MarshalJSON Uses

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

type AnnotateTextRequest Uses

type AnnotateTextRequest struct {
    // Document: Required. 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: Required. 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:"-"`
}

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

func (*AnnotateTextRequest) MarshalJSON Uses

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

type AnnotateTextResponse Uses

type AnnotateTextResponse struct {
    // Categories: Categories identified in the input document.
    Categories []*ClassificationCategory `json:"categories,omitempty"`

    // 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. "Categories") 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. "Categories") 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:"-"`
}

AnnotateTextResponse: The text annotations response message.

func (*AnnotateTextResponse) MarshalJSON Uses

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

type ClassificationCategory Uses

type ClassificationCategory struct {
    // Confidence: The classifier's confidence of the category. Number
    // represents how certain
    // the classifier is that this category represents the given text.
    Confidence float64 `json:"confidence,omitempty"`

    // Name: The name of the category representing the document, from the
    // [predefined
    // taxonomy](/natural-language/docs/categories).
    Name string `json:"name,omitempty"`

    // ForceSendFields is a list of field names (e.g. "Confidence") 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. "Confidence") 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:"-"`
}

ClassificationCategory: Represents a category returned from the text classifier.

func (*ClassificationCategory) MarshalJSON Uses

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

func (*ClassificationCategory) UnmarshalJSON Uses

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

type ClassifyTextRequest Uses

type ClassifyTextRequest struct {
    // Document: Required. Input document.
    Document *Document `json:"document,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:"-"`
}

ClassifyTextRequest: The document classification request message.

func (*ClassifyTextRequest) MarshalJSON Uses

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

type ClassifyTextResponse Uses

type ClassifyTextResponse struct {
    // Categories: Categories representing the input document.
    Categories []*ClassificationCategory `json:"categories,omitempty"`

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

    // ForceSendFields is a list of field names (e.g. "Categories") 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. "Categories") 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:"-"`
}

ClassifyTextResponse: The document classification response message.

func (*ClassifyTextResponse) MarshalJSON Uses

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

type DependencyEdge Uses

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)
    //   "ASP" - Aspect marker
    //   "GMOD" - Genitive modifier
    //   "GOBJ" - Genitive object
    //   "INFMOD" - Infinitival modifier
    //   "MES" - Measure
    //   "NCOMP" - Nominal complement of a noun
    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:"-"`
}

DependencyEdge: Represents dependency parse tree information for a token.

func (*DependencyEdge) MarshalJSON Uses

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

type Document Uses

type Document struct {
    // Content: The content of the input in string format.
    // Cloud audit logging exempt since it is based on user data.
    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:"-"`
}

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

Represents the input to API methods.

func (*Document) MarshalJSON Uses

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

type DocumentsAnalyzeEntitiesCall Uses

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

func (*DocumentsAnalyzeEntitiesCall) Context Uses

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 Uses

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 Uses

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 Uses

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 DocumentsAnalyzeEntitySentimentCall Uses

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

func (*DocumentsAnalyzeEntitySentimentCall) Context Uses

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

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 (*DocumentsAnalyzeEntitySentimentCall) Do Uses

func (c *DocumentsAnalyzeEntitySentimentCall) Do(opts ...googleapi.CallOption) (*AnalyzeEntitySentimentResponse, error)

Do executes the "language.documents.analyzeEntitySentiment" call. Exactly one of *AnalyzeEntitySentimentResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AnalyzeEntitySentimentResponse.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 (*DocumentsAnalyzeEntitySentimentCall) Fields Uses

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

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

func (*DocumentsAnalyzeEntitySentimentCall) Header Uses

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

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

type DocumentsAnalyzeSentimentCall Uses

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

func (*DocumentsAnalyzeSentimentCall) Context Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

func (*DocumentsAnalyzeSyntaxCall) Context Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

func (*DocumentsAnnotateTextCall) Context Uses

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 Uses

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 Uses

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 Uses

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 DocumentsClassifyTextCall Uses

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

func (*DocumentsClassifyTextCall) Context Uses

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

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 (*DocumentsClassifyTextCall) Do Uses

func (c *DocumentsClassifyTextCall) Do(opts ...googleapi.CallOption) (*ClassifyTextResponse, error)

Do executes the "language.documents.classifyText" call. Exactly one of *ClassifyTextResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ClassifyTextResponse.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 (*DocumentsClassifyTextCall) Fields Uses

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

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

func (*DocumentsClassifyTextCall) Header Uses

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

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

type DocumentsService Uses

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

func NewDocumentsService Uses

func NewDocumentsService(s *Service) *DocumentsService

func (*DocumentsService) AnalyzeEntities Uses

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) AnalyzeEntitySentiment Uses

func (r *DocumentsService) AnalyzeEntitySentiment(analyzeentitysentimentrequest *AnalyzeEntitySentimentRequest) *DocumentsAnalyzeEntitySentimentCall

AnalyzeEntitySentiment: Finds entities, similar to AnalyzeEntities in the text and analyzes sentiment associated with each entity and its mentions.

func (*DocumentsService) AnalyzeSentiment Uses

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

AnalyzeSentiment: Analyzes the sentiment of the provided text.

func (*DocumentsService) AnalyzeSyntax Uses

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 Uses

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

AnnotateText: A convenience method that provides all syntax, sentiment, entity, and classification features in one call.

func (*DocumentsService) ClassifyText Uses

func (r *DocumentsService) ClassifyText(classifytextrequest *ClassifyTextRequest) *DocumentsClassifyTextCall

ClassifyText: Classifies a document into categories.

type Entity Uses

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.
    //
    // For most entity types, the metadata is a Wikipedia URL
    // (`wikipedia_url`)
    // and Knowledge Graph MID (`mid`), if they are available. For the
    // metadata
    // associated with other entity types, see the Type table below.
    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"`

    // Sentiment: For calls to AnalyzeEntitySentiment or
    // if
    // AnnotateTextRequest.Features.extract_entity_sentiment is set to
    // true, this field will contain the aggregate sentiment expressed for
    // this
    // entity in the provided document.
    Sentiment *Sentiment `json:"sentiment,omitempty"`

    // Type: The entity type.
    //
    // Possible values:
    //   "UNKNOWN" - Unknown
    //   "PERSON" - Person
    //   "LOCATION" - Location
    //   "ORGANIZATION" - Organization
    //   "EVENT" - Event
    //   "WORK_OF_ART" - Artwork
    //   "CONSUMER_GOOD" - Consumer product
    //   "OTHER" - Other types of entities
    //   "PHONE_NUMBER" - Phone number
    //
    // The metadata lists the phone number, formatted according to
    // local
    // convention, plus whichever additional elements appear in the text:
    //
    // * `number` - the actual number, broken down into sections as per
    // local
    // convention
    // * `national_prefix` - country code, if detected
    // * `area_code` - region or area code, if detected
    // * `extension` - phone extension (to be dialed after connection),
    // if
    // detected
    //   "ADDRESS" - Address
    //
    // The metadata identifies the street number and locality plus
    // whichever
    // additional elements appear in the text:
    //
    // * `street_number` - street number
    // * `locality` - city or town
    // * `street_name` - street/route name, if detected
    // * `postal_code` - postal code, if detected
    // * `country` - country, if detected<
    // * `broad_region` - administrative area, such as the state, if
    // detected
    // * `narrow_region` - smaller administrative area, such as county,
    // if
    // detected
    // * `sublocality` - used in Asian addresses to demark a district within
    // a
    // city, if detected
    //   "DATE" - Date
    //
    // The metadata identifies the components of the date:
    //
    // * `year` - four digit year, if detected
    // * `month` - two digit month number, if detected
    // * `day` - two digit day number, if detected
    //   "NUMBER" - Number
    //
    // The metadata is the number itself.
    //   "PRICE" - Price
    //
    // The metadata identifies the `value` and `currency`.
    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:"-"`
}

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.

func (*Entity) MarshalJSON Uses

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

func (*Entity) UnmarshalJSON Uses

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

type EntityMention Uses

type EntityMention struct {
    // Sentiment: For calls to AnalyzeEntitySentiment or
    // if
    // AnnotateTextRequest.Features.extract_entity_sentiment is set to
    // true, this field will contain the sentiment expressed for this
    // mention of
    // the entity in the provided document.
    Sentiment *Sentiment `json:"sentiment,omitempty"`

    // 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. "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:"-"`
}

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

func (*EntityMention) MarshalJSON Uses

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

type Features Uses

type Features struct {
    // ClassifyText: Classify the full document into categories. If this is
    // true,
    // the API will use the default model which classifies into
    // a
    // [predefined taxonomy](/natural-language/docs/categories).
    ClassifyText bool `json:"classifyText,omitempty"`

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

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

    // ExtractEntitySentiment: Extract entities and their associated
    // sentiment.
    ExtractEntitySentiment bool `json:"extractEntitySentiment,omitempty"`

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

    // ForceSendFields is a list of field names (e.g. "ClassifyText") 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. "ClassifyText") 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:"-"`
}

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

func (*Features) MarshalJSON Uses

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

type PartOfSpeech Uses

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:"-"`
}

PartOfSpeech: Represents part of speech information for a token.

func (*PartOfSpeech) MarshalJSON Uses

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

type Sentence Uses

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:"-"`
}

Sentence: Represents a sentence in the input document.

func (*Sentence) MarshalJSON Uses

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

type Sentiment Uses

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:"-"`
}

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

func (*Sentiment) MarshalJSON Uses

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

func (*Sentiment) UnmarshalJSON Uses

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

type Service Uses

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 Uses

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

New creates a new Service. It uses the provided http.Client for requests.

Deprecated: please use NewService instead. To provide a custom HTTP client, use option.WithHTTPClient. If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.

func NewService Uses

func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error)

NewService creates a new Service.

type Status Uses

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 is 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:"-"`
}

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). Each `Status` message contains three pieces of data: error code, error message, and error details.

You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).

func (*Status) MarshalJSON Uses

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

type TextSpan Uses

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:"-"`
}

TextSpan: Represents an output piece of text.

func (*TextSpan) MarshalJSON Uses

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

type Token Uses

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:"-"`
}

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

func (*Token) MarshalJSON Uses

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

Package language imports 14 packages (graph). Updated 2019-07-21. Refresh now. Tools for package owners.