Documentation

Overview

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/v1"
...
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

Constants

View Source
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.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AnalyzeEntitiesRequest

    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

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

      type AnalyzeEntitiesResponse

      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

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

        type AnalyzeEntitySentimentRequest

        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

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

          type AnalyzeEntitySentimentResponse

          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

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

            type AnalyzeSentimentRequest

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

              AnalyzeSentimentRequest: The sentiment analysis request message.

              func (*AnalyzeSentimentRequest) MarshalJSON

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

              type AnalyzeSentimentResponse

              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

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

                type AnalyzeSyntaxRequest

                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

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

                  type AnalyzeSyntaxResponse

                  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

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

                    type AnnotateTextRequest

                    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

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

                      type AnnotateTextResponse

                      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

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

                        type ClassificationCategory

                        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

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

                          func (*ClassificationCategory) UnmarshalJSON

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

                          type ClassifyTextRequest

                          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

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

                            type ClassifyTextResponse

                            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

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

                              type DependencyEdge

                              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. (For more information on dependency labels, see http://www.aclweb.org/anthology/P13-2017

                                func (*DependencyEdge) MarshalJSON

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

                                type Document

                                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

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

                                  type DocumentsAnalyzeEntitiesCall

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

                                  func (*DocumentsAnalyzeEntitiesCall) Context

                                    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

                                      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

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

                                        func (*DocumentsAnalyzeEntitiesCall) Header

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

                                          type DocumentsAnalyzeEntitySentimentCall

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

                                          func (*DocumentsAnalyzeEntitySentimentCall) Context

                                            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

                                              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

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

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

                                                    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

                                                      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

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

                                                        func (*DocumentsAnalyzeSentimentCall) 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

                                                            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

                                                              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

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

                                                                func (*DocumentsAnalyzeSyntaxCall) 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

                                                                    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

                                                                      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

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

                                                                        func (*DocumentsAnnotateTextCall) Header

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

                                                                          type DocumentsClassifyTextCall

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

                                                                          func (*DocumentsClassifyTextCall) Context

                                                                            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

                                                                              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

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

                                                                                func (*DocumentsClassifyTextCall) 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) AnalyzeEntitySentiment

                                                                                    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

                                                                                      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.

                                                                                            func (*DocumentsService) ClassifyText

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

                                                                                              ClassifyText: Classifies a document into categories.

                                                                                              type Entity

                                                                                              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

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

                                                                                                func (*Entity) UnmarshalJSON

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

                                                                                                type EntityMention

                                                                                                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

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

                                                                                                  type Features

                                                                                                  type Features struct {
                                                                                                  	// ClassifyText: Classify the full document into 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.

                                                                                                    func (*Features) MarshalJSON

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

                                                                                                    type PartOfSpeech

                                                                                                    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. Parts of speech are as defined in http://www.lrec-conf.org/proceedings/lrec2012/pdf/274_Paper.pdf

                                                                                                      func (*PartOfSpeech) MarshalJSON

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

                                                                                                      type Sentence

                                                                                                      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

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

                                                                                                        type Sentiment

                                                                                                        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.

                                                                                                          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)

                                                                                                            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

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

                                                                                                              NewService creates a new Service.

                                                                                                              type Status

                                                                                                              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

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

                                                                                                                type TextSpan

                                                                                                                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

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

                                                                                                                  type Token

                                                                                                                  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

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

                                                                                                                    Source Files