Documentation

Overview

Package translate provides access to the Cloud Translation API.

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

For product documentation, see: https://cloud.google.com/translate/docs/quickstarts

Creating a client

Usage example:

import "google.golang.org/api/translate/v3beta1"
...
ctx := context.Background()
translateService, err := translate.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:

translateService, err := translate.NewService(ctx, option.WithScopes(translate.CloudTranslationScope))

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

translateService, err := translate.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, ...)
translateService, err := translate.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 (
	// View and manage your data across Google Cloud Platform services
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"

	// Translate text from one language to another using Google Translate
	CloudTranslationScope = "https://www.googleapis.com/auth/cloud-translation"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type BatchTranslateTextRequest

    type BatchTranslateTextRequest struct {
    	// Glossaries: Optional. Glossaries to be applied for translation.
    	// It's keyed by target language code.
    	Glossaries map[string]TranslateTextGlossaryConfig `json:"glossaries,omitempty"`
    
    	// InputConfigs: Required. Input configurations.
    	// The total number of files matched should be <= 1000.
    	// The total content size should be <= 100M Unicode codepoints.
    	// The files must use UTF-8 encoding.
    	InputConfigs []*InputConfig `json:"inputConfigs,omitempty"`
    
    	// Labels: Optional. The labels with user-defined metadata for the
    	// request.
    	//
    	// Label keys and values can be no longer than 63 characters
    	// (Unicode codepoints), can only contain lowercase letters,
    	// numeric
    	// characters, underscores and dashes. International characters are
    	// allowed.
    	// Label values are optional. Label keys must start with a letter.
    	//
    	// See https://cloud.google.com/translate/docs/labels for more
    	// information.
    	Labels map[string]string `json:"labels,omitempty"`
    
    	// Models: Optional. The models to use for translation. Map's key is
    	// target language
    	// code. Map's value is model name. Value can be a built-in general
    	// model,
    	// or an AutoML Translation model.
    	//
    	// The value format depends on model type:
    	//
    	// - AutoML Translation models:
    	//
    	// `projects/{project-number-or-id}/locations/{location-id}/models/{model
    	// -id}`
    	//
    	// - General (built-in) models:
    	//
    	// `projects/{project-number-or-id}/locations/{location-id}/models/genera
    	// l/nmt`,
    	//
    	// `projects/{project-number-or-id}/locations/{location-id}/models/genera
    	// l/base`
    	//
    	//
    	// If the map is empty or a specific model is
    	// not requested for a language pair, then default google model (nmt) is
    	// used.
    	Models map[string]string `json:"models,omitempty"`
    
    	// OutputConfig: Required. Output configuration.
    	// If 2 input configs match to the same file (that is, same input
    	// path),
    	// we don't generate output for duplicate inputs.
    	OutputConfig *OutputConfig `json:"outputConfig,omitempty"`
    
    	// SourceLanguageCode: Required. Source language code.
    	SourceLanguageCode string `json:"sourceLanguageCode,omitempty"`
    
    	// TargetLanguageCodes: Required. Specify up to 10 language codes here.
    	TargetLanguageCodes []string `json:"targetLanguageCodes,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "Glossaries") 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. "Glossaries") 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:"-"`
    }

      BatchTranslateTextRequest: The batch translation request.

      func (*BatchTranslateTextRequest) MarshalJSON

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

      type CancelOperationRequest

      type CancelOperationRequest struct {
      }

        CancelOperationRequest: The request message for Operations.CancelOperation.

        type DetectLanguageRequest

        type DetectLanguageRequest struct {
        	// Content: The content of the input stored as a string.
        	Content string `json:"content,omitempty"`
        
        	// Labels: Optional. The labels with user-defined metadata for the
        	// request.
        	//
        	// Label keys and values can be no longer than 63 characters
        	// (Unicode codepoints), can only contain lowercase letters,
        	// numeric
        	// characters, underscores and dashes. International characters are
        	// allowed.
        	// Label values are optional. Label keys must start with a letter.
        	//
        	// See https://cloud.google.com/translate/docs/labels for more
        	// information.
        	Labels map[string]string `json:"labels,omitempty"`
        
        	// MimeType: Optional. The format of the source text, for example,
        	// "text/html",
        	// "text/plain". If left blank, the MIME type defaults to "text/html".
        	MimeType string `json:"mimeType,omitempty"`
        
        	// Model: Optional. The language detection model to be
        	// used.
        	//
        	// Format:
        	// `projects/{project-number-or-id}/locations/{location-id
        	// }/models/language-detection/{model-id}`
        	//
        	// Only one language detection model is currently
        	// supported:
        	// `projects/{project-number-or-id}/locations/{location-id}/mo
        	// dels/language-detection/default`.
        	//
        	// If not specified, the default model is used.
        	Model string `json:"model,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:"-"`
        }

          DetectLanguageRequest: The request message for language detection.

          func (*DetectLanguageRequest) MarshalJSON

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

          type DetectLanguageResponse

          type DetectLanguageResponse struct {
          	// Languages: A list of detected languages sorted by detection
          	// confidence in descending
          	// order. The most probable language first.
          	Languages []*DetectedLanguage `json:"languages,omitempty"`
          
          	// ServerResponse contains the HTTP response code and headers from the
          	// server.
          	googleapi.ServerResponse `json:"-"`
          
          	// ForceSendFields is a list of field names (e.g. "Languages") 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. "Languages") 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:"-"`
          }

            DetectLanguageResponse: The response message for language detection.

            func (*DetectLanguageResponse) MarshalJSON

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

            type DetectedLanguage

            type DetectedLanguage struct {
            	// Confidence: The confidence of the detection result for this language.
            	Confidence float64 `json:"confidence,omitempty"`
            
            	// LanguageCode: The BCP-47 language code of source content in the
            	// request, detected
            	// automatically.
            	LanguageCode string `json:"languageCode,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:"-"`
            }

              DetectedLanguage: The response message for language detection.

              func (*DetectedLanguage) MarshalJSON

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

              func (*DetectedLanguage) UnmarshalJSON

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

              type Empty

              type Empty struct {
              	// ServerResponse contains the HTTP response code and headers from the
              	// server.
              	googleapi.ServerResponse `json:"-"`
              }

                Empty: A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:

                service Foo {
                  rpc Bar(google.protobuf.Empty) returns
                

                (google.protobuf.Empty);

                }
                

                The JSON representation for `Empty` is empty JSON object `{}`.

                type GcsDestination

                type GcsDestination struct {
                	// OutputUriPrefix: Required. There must be no files under
                	// 'output_uri_prefix'.
                	// 'output_uri_prefix' must end with "/" and start with "gs://",
                	// otherwise an
                	// INVALID_ARGUMENT (400) error is returned.
                	OutputUriPrefix string `json:"outputUriPrefix,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "OutputUriPrefix") 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. "OutputUriPrefix") 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:"-"`
                }

                  GcsDestination: The Google Cloud Storage location for the output content.

                  func (*GcsDestination) MarshalJSON

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

                  type GcsSource

                  type GcsSource struct {
                  	// InputUri: Required. Source data URI. For example,
                  	// `gs://my_bucket/my_object`.
                  	InputUri string `json:"inputUri,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "InputUri") 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. "InputUri") 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:"-"`
                  }

                    GcsSource: The Google Cloud Storage location for the input content.

                    func (*GcsSource) MarshalJSON

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

                    type Glossary

                    type Glossary struct {
                    	// EndTime: Output only. When the glossary creation was finished.
                    	EndTime string `json:"endTime,omitempty"`
                    
                    	// EntryCount: Output only. The number of entries defined in the
                    	// glossary.
                    	EntryCount int64 `json:"entryCount,omitempty"`
                    
                    	// InputConfig: Required. Provides examples to build the glossary
                    	// from.
                    	// Total glossary must not exceed 10M Unicode codepoints.
                    	InputConfig *GlossaryInputConfig `json:"inputConfig,omitempty"`
                    
                    	// LanguageCodesSet: Used with equivalent term set glossaries.
                    	LanguageCodesSet *LanguageCodesSet `json:"languageCodesSet,omitempty"`
                    
                    	// LanguagePair: Used with unidirectional glossaries.
                    	LanguagePair *LanguageCodePair `json:"languagePair,omitempty"`
                    
                    	// Name: Required. The resource name of the glossary. Glossary names
                    	// have the
                    	// form
                    	// `projects/{project-number-or-id}/locations/{location-id}/glossari
                    	// es/{glossary-id}`.
                    	Name string `json:"name,omitempty"`
                    
                    	// SubmitTime: Output only. When CreateGlossary was called.
                    	SubmitTime string `json:"submitTime,omitempty"`
                    
                    	// ServerResponse contains the HTTP response code and headers from the
                    	// server.
                    	googleapi.ServerResponse `json:"-"`
                    
                    	// ForceSendFields is a list of field names (e.g. "EndTime") 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. "EndTime") 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:"-"`
                    }

                      Glossary: Represents a glossary built from user provided data.

                      func (*Glossary) MarshalJSON

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

                      type GlossaryInputConfig

                      type GlossaryInputConfig struct {
                      	// GcsSource: Required. Google Cloud Storage location of glossary
                      	// data.
                      	// File format is determined based on the filename extension. API
                      	// returns
                      	// [google.rpc.Code.INVALID_ARGUMENT] for unsupported URI-s and
                      	// file
                      	// formats. Wildcards are not allowed. This must be a single file in one
                      	// of
                      	// the following formats:
                      	//
                      	// For unidirectional glossaries:
                      	//
                      	// - TSV/CSV (`.tsv`/`.csv`): 2 column file, tab- or comma-separated.
                      	//   The first column is source text. The second column is target text.
                      	//   The file must not contain headers. That is, the first row is data,
                      	// not
                      	//   column names.
                      	//
                      	// - TMX (`.tmx`): TMX file with parallel data defining source/target
                      	// term
                      	// pairs.
                      	//
                      	// For equivalent term sets glossaries:
                      	//
                      	// - CSV (`.csv`): Multi-column CSV file defining equivalent glossary
                      	// terms
                      	//   in multiple languages. The format is defined for Google
                      	// Translation
                      	//   Toolkit and documented in [Use a
                      	//
                      	// glossary](https://support.google.com/translatortoolkit/answer/6306379?
                      	// hl=en).
                      	GcsSource *GcsSource `json:"gcsSource,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "GcsSource") 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. "GcsSource") 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:"-"`
                      }

                        GlossaryInputConfig: Input configuration for glossaries.

                        func (*GlossaryInputConfig) MarshalJSON

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

                        type InputConfig

                        type InputConfig struct {
                        	// GcsSource: Required. Google Cloud Storage location for the source
                        	// input.
                        	// This can be a single file (for
                        	// example,
                        	// `gs://translation-test/input.tsv`) or a wildcard (for
                        	// example,
                        	// `gs://translation-test/*`). If a file extension is `.tsv`, it
                        	// can
                        	// contain either one or two columns. The first column (optional) is the
                        	// id
                        	// of the text request. If the first column is missing, we use the
                        	// row
                        	// number (0-based) from the input file as the ID in the output file.
                        	// The
                        	// second column is the actual text to be
                        	//  translated. We recommend each row be <= 10K Unicode
                        	// codepoints,
                        	// otherwise an error might be returned.
                        	// Note that the input tsv must be RFC 4180 compliant.
                        	//
                        	// You could use https://github.com/Clever/csvlint to check
                        	// potential
                        	// formatting errors in your tsv file.
                        	// csvlint --delimiter='\t' your_input_file.tsv
                        	//
                        	// The other supported file extensions are `.txt` or `.html`, which
                        	// is
                        	// treated as a single large chunk of text.
                        	GcsSource *GcsSource `json:"gcsSource,omitempty"`
                        
                        	// MimeType: Optional. Can be "text/plain" or "text/html".
                        	// For `.tsv`, "text/html" is used if mime_type is missing.
                        	// For `.html`, this field must be "text/html" or empty.
                        	// For `.txt`, this field must be "text/plain" or empty.
                        	MimeType string `json:"mimeType,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "GcsSource") 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. "GcsSource") 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:"-"`
                        }

                          InputConfig: Input configuration for BatchTranslateText request.

                          func (*InputConfig) MarshalJSON

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

                          type LanguageCodePair

                          type LanguageCodePair struct {
                          	// SourceLanguageCode: Required. The BCP-47 language code of the input
                          	// text, for example,
                          	// "en-US". Expected to be an exact match for
                          	// GlossaryTerm.language_code.
                          	SourceLanguageCode string `json:"sourceLanguageCode,omitempty"`
                          
                          	// TargetLanguageCode: Required. The BCP-47 language code for
                          	// translation output, for example,
                          	// "zh-CN". Expected to be an exact match for
                          	// GlossaryTerm.language_code.
                          	TargetLanguageCode string `json:"targetLanguageCode,omitempty"`
                          
                          	// ForceSendFields is a list of field names (e.g. "SourceLanguageCode")
                          	// 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. "SourceLanguageCode") 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:"-"`
                          }

                            LanguageCodePair: Used with unidirectional glossaries.

                            func (*LanguageCodePair) MarshalJSON

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

                            type LanguageCodesSet

                            type LanguageCodesSet struct {
                            	// LanguageCodes: The BCP-47 language code(s) for terms defined in the
                            	// glossary.
                            	// All entries are unique. The list contains at least two
                            	// entries.
                            	// Expected to be an exact match for GlossaryTerm.language_code.
                            	LanguageCodes []string `json:"languageCodes,omitempty"`
                            
                            	// ForceSendFields is a list of field names (e.g. "LanguageCodes") 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. "LanguageCodes") 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:"-"`
                            }

                              LanguageCodesSet: Used with equivalent term set glossaries.

                              func (*LanguageCodesSet) MarshalJSON

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

                              type ListGlossariesResponse

                              type ListGlossariesResponse struct {
                              	// Glossaries: The list of glossaries for a project.
                              	Glossaries []*Glossary `json:"glossaries,omitempty"`
                              
                              	// NextPageToken: A token to retrieve a page of results. Pass this value
                              	// in the
                              	// [ListGlossariesRequest.page_token] field in the subsequent call
                              	// to
                              	// `ListGlossaries` method to retrieve the next page of results.
                              	NextPageToken string `json:"nextPageToken,omitempty"`
                              
                              	// ServerResponse contains the HTTP response code and headers from the
                              	// server.
                              	googleapi.ServerResponse `json:"-"`
                              
                              	// ForceSendFields is a list of field names (e.g. "Glossaries") 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. "Glossaries") 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:"-"`
                              }

                                ListGlossariesResponse: Response message for ListGlossaries.

                                func (*ListGlossariesResponse) MarshalJSON

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

                                type ListLocationsResponse

                                type ListLocationsResponse struct {
                                	// Locations: A list of locations that matches the specified filter in
                                	// the request.
                                	Locations []*Location `json:"locations,omitempty"`
                                
                                	// NextPageToken: The standard List next-page token.
                                	NextPageToken string `json:"nextPageToken,omitempty"`
                                
                                	// ServerResponse contains the HTTP response code and headers from the
                                	// server.
                                	googleapi.ServerResponse `json:"-"`
                                
                                	// ForceSendFields is a list of field names (e.g. "Locations") 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. "Locations") 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:"-"`
                                }

                                  ListLocationsResponse: The response message for Locations.ListLocations.

                                  func (*ListLocationsResponse) MarshalJSON

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

                                  type ListOperationsResponse

                                  type ListOperationsResponse struct {
                                  	// NextPageToken: The standard List next-page token.
                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                  
                                  	// Operations: A list of operations that matches the specified filter in
                                  	// the request.
                                  	Operations []*Operation `json:"operations,omitempty"`
                                  
                                  	// ServerResponse contains the HTTP response code and headers from the
                                  	// server.
                                  	googleapi.ServerResponse `json:"-"`
                                  
                                  	// ForceSendFields is a list of field names (e.g. "NextPageToken") 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. "NextPageToken") 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:"-"`
                                  }

                                    ListOperationsResponse: The response message for Operations.ListOperations.

                                    func (*ListOperationsResponse) MarshalJSON

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

                                    type Location

                                    type Location struct {
                                    	// DisplayName: The friendly name for this location, typically a nearby
                                    	// city name.
                                    	// For example, "Tokyo".
                                    	DisplayName string `json:"displayName,omitempty"`
                                    
                                    	// Labels: Cross-service attributes for the location. For example
                                    	//
                                    	//     {"cloud.googleapis.com/region": "us-east1"}
                                    	Labels map[string]string `json:"labels,omitempty"`
                                    
                                    	// LocationId: The canonical id for this location. For example:
                                    	// "us-east1".
                                    	LocationId string `json:"locationId,omitempty"`
                                    
                                    	// Metadata: Service-specific metadata. For example the available
                                    	// capacity at the given
                                    	// location.
                                    	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
                                    
                                    	// Name: Resource name for the location, which may vary between
                                    	// implementations.
                                    	// For example: "projects/example-project/locations/us-east1"
                                    	Name string `json:"name,omitempty"`
                                    
                                    	// ServerResponse contains the HTTP response code and headers from the
                                    	// server.
                                    	googleapi.ServerResponse `json:"-"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "DisplayName") 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. "DisplayName") 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:"-"`
                                    }

                                      Location: A resource that represents Google Cloud Platform location.

                                      func (*Location) MarshalJSON

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

                                      type Operation

                                      type Operation struct {
                                      	// Done: If the value is `false`, it means the operation is still in
                                      	// progress.
                                      	// If `true`, the operation is completed, and either `error` or
                                      	// `response` is
                                      	// available.
                                      	Done bool `json:"done,omitempty"`
                                      
                                      	// Error: The error result of the operation in case of failure or
                                      	// cancellation.
                                      	Error *Status `json:"error,omitempty"`
                                      
                                      	// Metadata: Service-specific metadata associated with the operation.
                                      	// It typically
                                      	// contains progress information and common metadata such as create
                                      	// time.
                                      	// Some services might not provide such metadata.  Any method that
                                      	// returns a
                                      	// long-running operation should document the metadata type, if any.
                                      	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
                                      
                                      	// Name: The server-assigned name, which is only unique within the same
                                      	// service that
                                      	// originally returns it. If you use the default HTTP mapping,
                                      	// the
                                      	// `name` should be a resource name ending with
                                      	// `operations/{unique_id}`.
                                      	Name string `json:"name,omitempty"`
                                      
                                      	// Response: The normal response of the operation in case of success.
                                      	// If the original
                                      	// method returns no data on success, such as `Delete`, the response
                                      	// is
                                      	// `google.protobuf.Empty`.  If the original method is
                                      	// standard
                                      	// `Get`/`Create`/`Update`, the response should be the resource.  For
                                      	// other
                                      	// methods, the response should have the type `XxxResponse`, where
                                      	// `Xxx`
                                      	// is the original method name.  For example, if the original method
                                      	// name
                                      	// is `TakeSnapshot()`, the inferred response type
                                      	// is
                                      	// `TakeSnapshotResponse`.
                                      	Response googleapi.RawMessage `json:"response,omitempty"`
                                      
                                      	// ServerResponse contains the HTTP response code and headers from the
                                      	// server.
                                      	googleapi.ServerResponse `json:"-"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Done") 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. "Done") 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:"-"`
                                      }

                                        Operation: This resource represents a long-running operation that is the result of a network API call.

                                        func (*Operation) MarshalJSON

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

                                        type OutputConfig

                                        type OutputConfig struct {
                                        	// GcsDestination: Google Cloud Storage destination for output
                                        	// content.
                                        	// For every single input file (for example, gs://a/b/c.[extension]),
                                        	// we
                                        	// generate at most 2 * n output files. (n is the # of
                                        	// target_language_codes
                                        	// in the BatchTranslateTextRequest).
                                        	//
                                        	// Output files (tsv) generated are compliant with RFC 4180 except
                                        	// that
                                        	// record delimiters are '\n' instead of '\r\n'. We don't provide any
                                        	// way to
                                        	// change record delimiters.
                                        	//
                                        	// While the input files are being processed, we write/update an index
                                        	// file
                                        	// 'index.csv'  under 'output_uri_prefix' (for
                                        	// example,
                                        	// gs://translation-test/index.csv) The index file is generated/updated
                                        	// as
                                        	// new files are being translated. The format
                                        	// is:
                                        	//
                                        	// input_file,target_language_code,translations_file,errors_file,
                                        	// gl
                                        	// ossary_translations_file,glossary_errors_file
                                        	//
                                        	// input_file is one file we matched using
                                        	// gcs_source.input_uri.
                                        	// target_language_code is provided in the request.
                                        	// translations_file contains the translations. (details provided
                                        	// below)
                                        	// errors_file contains the errors during processing of the file.
                                        	// (details
                                        	// below). Both translations_file and errors_file could be empty
                                        	// strings if we have no content to output.
                                        	// glossary_translations_file and glossary_errors_file are always
                                        	// empty
                                        	// strings if the input_file is tsv. They could also be empty if we have
                                        	// no
                                        	// content to output.
                                        	//
                                        	// Once a row is present in index.csv, the input/output matching
                                        	// never
                                        	// changes. Callers should also expect all the content in input_file
                                        	// are
                                        	// processed and ready to be consumed (that is, no partial output file
                                        	// is
                                        	// written).
                                        	//
                                        	// The format of translations_file (for target language code 'trg')
                                        	// is:
                                        	// gs://translation_test/a_b_c_'trg'_translations.[extension]
                                        	//
                                        	// If the input file extension is tsv, the output has the
                                        	// following
                                        	// columns:
                                        	// Column 1: ID of the request provided in the input, if it's
                                        	// not
                                        	// provided in the input, then the input row number is used
                                        	// (0-based).
                                        	// Column 2: source sentence.
                                        	// Column 3: translation without applying a glossary. Empty string if
                                        	// there
                                        	// is an error.
                                        	// Column 4 (only present if a glossary is provided in the
                                        	// request):
                                        	// translation after applying the glossary. Empty string if there is
                                        	// an
                                        	// error applying the glossary. Could be same string as column 3 if
                                        	// there is
                                        	// no glossary applied.
                                        	//
                                        	// If input file extension is a txt or html, the translation is
                                        	// directly
                                        	// written to the output file. If glossary is requested, a
                                        	// separate
                                        	// glossary_translations_file has format
                                        	// of
                                        	// gs://translation_test/a_b_c_'trg'_glossary_translations.[extension]
                                        	//
                                        	//
                                        	// The format of errors file (for target language code 'trg')
                                        	// is:
                                        	// gs://translation_test/a_b_c_'trg'_errors.[extension]
                                        	//
                                        	// If the input file extension is tsv, errors_file contains the
                                        	// following:
                                        	// Column 1: ID of the request provided in the input, if it's
                                        	// not
                                        	// provided in the input, then the input row number is used
                                        	// (0-based).
                                        	// Column 2: source sentence.
                                        	// Column 3: Error detail for the translation. Could be empty.
                                        	// Column 4 (only present if a glossary is provided in the
                                        	// request):
                                        	// Error when applying the glossary.
                                        	//
                                        	// If the input file extension is txt or html, glossary_error_file will
                                        	// be
                                        	// generated that contains error details. glossary_error_file has format
                                        	// of
                                        	// gs://translation_test/a_b_c_'trg'_glossary_errors.[extension]
                                        	GcsDestination *GcsDestination `json:"gcsDestination,omitempty"`
                                        
                                        	// ForceSendFields is a list of field names (e.g. "GcsDestination") 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. "GcsDestination") 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:"-"`
                                        }

                                          OutputConfig: Output configuration for BatchTranslateText request.

                                          func (*OutputConfig) MarshalJSON

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

                                          type ProjectsDetectLanguageCall

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

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

                                              Do executes the "translate.projects.detectLanguage" call. Exactly one of *DetectLanguageResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *DetectLanguageResponse.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 (*ProjectsDetectLanguageCall) Fields

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

                                                func (*ProjectsDetectLanguageCall) Header

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

                                                  type ProjectsGetSupportedLanguagesCall

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

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

                                                    func (c *ProjectsGetSupportedLanguagesCall) DisplayLanguageCode(displayLanguageCode string) *ProjectsGetSupportedLanguagesCall

                                                      DisplayLanguageCode sets the optional parameter "displayLanguageCode": The language to use to return localized, human readable names of supported languages. If missing, then display names are not returned in a response.

                                                      func (*ProjectsGetSupportedLanguagesCall) Do

                                                        Do executes the "translate.projects.getSupportedLanguages" call. Exactly one of *SupportedLanguages or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *SupportedLanguages.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 (*ProjectsGetSupportedLanguagesCall) Fields

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

                                                          func (*ProjectsGetSupportedLanguagesCall) Header

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

                                                            func (*ProjectsGetSupportedLanguagesCall) IfNoneMatch

                                                              IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                              func (*ProjectsGetSupportedLanguagesCall) Model

                                                                Model sets the optional parameter "model": Get supported languages of this model.

                                                                The format depends on model type:

                                                                - AutoML Translation models:

                                                                `projects/{project-number-or-id}/locations/{location-id}/models/{model -id}`

                                                                - General (built-in) models:

                                                                `projects/{project-number-or-id}/locations/{location-id}/models/genera l/nmt`,

                                                                `projects/{project-number-or-id}/locations/{location-id}/models/genera l/base`

                                                                Returns languages supported by the specified model. If missing, we get supported languages of Google general base (PBMT) model.

                                                                type ProjectsLocationsBatchTranslateTextCall

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

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

                                                                    Do executes the "translate.projects.locations.batchTranslateText" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ProjectsLocationsBatchTranslateTextCall) Fields

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

                                                                      func (*ProjectsLocationsBatchTranslateTextCall) Header

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

                                                                        type ProjectsLocationsDetectLanguageCall

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

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

                                                                            Do executes the "translate.projects.locations.detectLanguage" call. Exactly one of *DetectLanguageResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *DetectLanguageResponse.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 (*ProjectsLocationsDetectLanguageCall) Fields

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

                                                                              func (*ProjectsLocationsDetectLanguageCall) Header

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

                                                                                type ProjectsLocationsGetCall

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

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

                                                                                    Do executes the "translate.projects.locations.get" call. Exactly one of *Location or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Location.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 (*ProjectsLocationsGetCall) Fields

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

                                                                                      func (*ProjectsLocationsGetCall) Header

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

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

                                                                                        func (*ProjectsLocationsGetCall) IfNoneMatch

                                                                                        func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall

                                                                                          IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                          type ProjectsLocationsGetSupportedLanguagesCall

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

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

                                                                                              DisplayLanguageCode sets the optional parameter "displayLanguageCode": The language to use to return localized, human readable names of supported languages. If missing, then display names are not returned in a response.

                                                                                              func (*ProjectsLocationsGetSupportedLanguagesCall) Do

                                                                                                Do executes the "translate.projects.locations.getSupportedLanguages" call. Exactly one of *SupportedLanguages or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *SupportedLanguages.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 (*ProjectsLocationsGetSupportedLanguagesCall) Fields

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

                                                                                                  func (*ProjectsLocationsGetSupportedLanguagesCall) Header

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

                                                                                                    func (*ProjectsLocationsGetSupportedLanguagesCall) IfNoneMatch

                                                                                                      IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                      func (*ProjectsLocationsGetSupportedLanguagesCall) Model

                                                                                                        Model sets the optional parameter "model": Get supported languages of this model.

                                                                                                        The format depends on model type:

                                                                                                        - AutoML Translation models:

                                                                                                        `projects/{project-number-or-id}/locations/{location-id}/models/{model -id}`

                                                                                                        - General (built-in) models:

                                                                                                        `projects/{project-number-or-id}/locations/{location-id}/models/genera l/nmt`,

                                                                                                        `projects/{project-number-or-id}/locations/{location-id}/models/genera l/base`

                                                                                                        Returns languages supported by the specified model. If missing, we get supported languages of Google general base (PBMT) model.

                                                                                                        type ProjectsLocationsGlossariesCreateCall

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

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

                                                                                                            Do executes the "translate.projects.locations.glossaries.create" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ProjectsLocationsGlossariesCreateCall) Fields

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

                                                                                                              func (*ProjectsLocationsGlossariesCreateCall) Header

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

                                                                                                                type ProjectsLocationsGlossariesDeleteCall

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

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

                                                                                                                    Do executes the "translate.projects.locations.glossaries.delete" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ProjectsLocationsGlossariesDeleteCall) Fields

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

                                                                                                                      func (*ProjectsLocationsGlossariesDeleteCall) Header

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

                                                                                                                        type ProjectsLocationsGlossariesGetCall

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

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

                                                                                                                            Do executes the "translate.projects.locations.glossaries.get" call. Exactly one of *Glossary or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Glossary.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 (*ProjectsLocationsGlossariesGetCall) Fields

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

                                                                                                                              func (*ProjectsLocationsGlossariesGetCall) Header

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

                                                                                                                                func (*ProjectsLocationsGlossariesGetCall) IfNoneMatch

                                                                                                                                  IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                  type ProjectsLocationsGlossariesListCall

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

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

                                                                                                                                      Do executes the "translate.projects.locations.glossaries.list" call. Exactly one of *ListGlossariesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListGlossariesResponse.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 (*ProjectsLocationsGlossariesListCall) Fields

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

                                                                                                                                        func (*ProjectsLocationsGlossariesListCall) Filter

                                                                                                                                          Filter sets the optional parameter "filter": Filter specifying constraints of a list operation. Filtering is not supported yet, and the parameter currently has no effect. If missing, no filtering is performed.

                                                                                                                                          func (*ProjectsLocationsGlossariesListCall) Header

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

                                                                                                                                            func (*ProjectsLocationsGlossariesListCall) IfNoneMatch

                                                                                                                                              IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                              func (*ProjectsLocationsGlossariesListCall) PageSize

                                                                                                                                                PageSize sets the optional parameter "pageSize": Requested page size. The server may return fewer glossaries than requested. If unspecified, the server picks an appropriate default.

                                                                                                                                                func (*ProjectsLocationsGlossariesListCall) PageToken

                                                                                                                                                  PageToken sets the optional parameter "pageToken": A token identifying a page of results the server should return. Typically, this is the value of [ListGlossariesResponse.next_page_token] returned from the previous call to `ListGlossaries` method. The first page is returned if `page_token`is empty or missing.

                                                                                                                                                  func (*ProjectsLocationsGlossariesListCall) Pages

                                                                                                                                                    Pages invokes f for each page of results. A non-nil error returned from f will halt the iteration. The provided context supersedes any context provided to the Context method.

                                                                                                                                                    type ProjectsLocationsGlossariesService

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

                                                                                                                                                    func NewProjectsLocationsGlossariesService

                                                                                                                                                    func NewProjectsLocationsGlossariesService(s *Service) *ProjectsLocationsGlossariesService

                                                                                                                                                    func (*ProjectsLocationsGlossariesService) Create

                                                                                                                                                      Create: Creates a glossary and returns the long-running operation. Returns NOT_FOUND, if the project doesn't exist.

                                                                                                                                                      func (*ProjectsLocationsGlossariesService) Delete

                                                                                                                                                        Delete: Deletes a glossary, or cancels glossary construction if the glossary isn't created yet. Returns NOT_FOUND, if the glossary doesn't exist.

                                                                                                                                                        func (*ProjectsLocationsGlossariesService) Get

                                                                                                                                                          Get: Gets a glossary. Returns NOT_FOUND, if the glossary doesn't exist.

                                                                                                                                                          func (*ProjectsLocationsGlossariesService) List

                                                                                                                                                            List: Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't exist.

                                                                                                                                                            type ProjectsLocationsListCall

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

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

                                                                                                                                                                Do executes the "translate.projects.locations.list" call. Exactly one of *ListLocationsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListLocationsResponse.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 (*ProjectsLocationsListCall) Fields

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

                                                                                                                                                                  func (*ProjectsLocationsListCall) Filter

                                                                                                                                                                    Filter sets the optional parameter "filter": The standard list filter.

                                                                                                                                                                    func (*ProjectsLocationsListCall) Header

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

                                                                                                                                                                      func (*ProjectsLocationsListCall) IfNoneMatch

                                                                                                                                                                      func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall

                                                                                                                                                                        IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                        func (*ProjectsLocationsListCall) PageSize

                                                                                                                                                                          PageSize sets the optional parameter "pageSize": The standard list page size.

                                                                                                                                                                          func (*ProjectsLocationsListCall) PageToken

                                                                                                                                                                            PageToken sets the optional parameter "pageToken": The standard list page token.

                                                                                                                                                                            func (*ProjectsLocationsListCall) Pages

                                                                                                                                                                              Pages invokes f for each page of results. A non-nil error returned from f will halt the iteration. The provided context supersedes any context provided to the Context method.

                                                                                                                                                                              type ProjectsLocationsOperationsCancelCall

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

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

                                                                                                                                                                                  Do executes the "translate.projects.locations.operations.cancel" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.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 (*ProjectsLocationsOperationsCancelCall) Fields

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

                                                                                                                                                                                    func (*ProjectsLocationsOperationsCancelCall) Header

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

                                                                                                                                                                                      type ProjectsLocationsOperationsDeleteCall

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

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

                                                                                                                                                                                          Do executes the "translate.projects.locations.operations.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.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 (*ProjectsLocationsOperationsDeleteCall) Fields

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

                                                                                                                                                                                            func (*ProjectsLocationsOperationsDeleteCall) Header

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

                                                                                                                                                                                              type ProjectsLocationsOperationsGetCall

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

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

                                                                                                                                                                                                  Do executes the "translate.projects.locations.operations.get" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ProjectsLocationsOperationsGetCall) Fields

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

                                                                                                                                                                                                    func (*ProjectsLocationsOperationsGetCall) Header

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

                                                                                                                                                                                                      func (*ProjectsLocationsOperationsGetCall) IfNoneMatch

                                                                                                                                                                                                        IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                        type ProjectsLocationsOperationsListCall

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

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

                                                                                                                                                                                                            Do executes the "translate.projects.locations.operations.list" call. Exactly one of *ListOperationsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListOperationsResponse.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 (*ProjectsLocationsOperationsListCall) Fields

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

                                                                                                                                                                                                              func (*ProjectsLocationsOperationsListCall) Filter

                                                                                                                                                                                                                Filter sets the optional parameter "filter": The standard list filter.

                                                                                                                                                                                                                func (*ProjectsLocationsOperationsListCall) Header

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

                                                                                                                                                                                                                  func (*ProjectsLocationsOperationsListCall) IfNoneMatch

                                                                                                                                                                                                                    IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                                                                                                    func (*ProjectsLocationsOperationsListCall) PageSize

                                                                                                                                                                                                                      PageSize sets the optional parameter "pageSize": The standard list page size.

                                                                                                                                                                                                                      func (*ProjectsLocationsOperationsListCall) PageToken

                                                                                                                                                                                                                        PageToken sets the optional parameter "pageToken": The standard list page token.

                                                                                                                                                                                                                        func (*ProjectsLocationsOperationsListCall) Pages

                                                                                                                                                                                                                          Pages invokes f for each page of results. A non-nil error returned from f will halt the iteration. The provided context supersedes any context provided to the Context method.

                                                                                                                                                                                                                          type ProjectsLocationsOperationsService

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

                                                                                                                                                                                                                          func NewProjectsLocationsOperationsService

                                                                                                                                                                                                                          func NewProjectsLocationsOperationsService(s *Service) *ProjectsLocationsOperationsService

                                                                                                                                                                                                                          func (*ProjectsLocationsOperationsService) Cancel

                                                                                                                                                                                                                            Cancel: Starts asynchronous cancellation on a long-running operation.

                                                                                                                                                                                                                            The server
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.

                                                                                                                                                                                                                            func (*ProjectsLocationsOperationsService) Delete

                                                                                                                                                                                                                              Delete: Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.

                                                                                                                                                                                                                              func (*ProjectsLocationsOperationsService) Get

                                                                                                                                                                                                                                Get: Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.

                                                                                                                                                                                                                                func (*ProjectsLocationsOperationsService) List

                                                                                                                                                                                                                                  List: Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.

                                                                                                                                                                                                                                  NOTE: the `name` binding allows API services to override the binding to use different resource name schemes, such as `users/*/operations`. To override the binding, API services can add a binding such as "/v1/{name=users/*}/operations" to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id.

                                                                                                                                                                                                                                  func (*ProjectsLocationsOperationsService) Wait

                                                                                                                                                                                                                                    Wait: Waits for the specified long-running operation until it is done or reaches at most a specified timeout, returning the latest state. If the operation is already done, the latest state is immediately returned. If the timeout specified is greater than the default HTTP/RPC timeout, the HTTP/RPC timeout is used. If the server does not support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Note that this method is on a best-effort basis. It may return the latest state before the specified timeout (including immediately), meaning even an immediate response is no guarantee that the operation is done.

                                                                                                                                                                                                                                    type ProjectsLocationsOperationsWaitCall

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

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

                                                                                                                                                                                                                                        Do executes the "translate.projects.locations.operations.wait" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ProjectsLocationsOperationsWaitCall) Fields

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

                                                                                                                                                                                                                                          func (*ProjectsLocationsOperationsWaitCall) Header

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

                                                                                                                                                                                                                                            type ProjectsLocationsService

                                                                                                                                                                                                                                            type ProjectsLocationsService struct {
                                                                                                                                                                                                                                            	Glossaries *ProjectsLocationsGlossariesService
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	Operations *ProjectsLocationsOperationsService
                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            func NewProjectsLocationsService

                                                                                                                                                                                                                                            func NewProjectsLocationsService(s *Service) *ProjectsLocationsService

                                                                                                                                                                                                                                            func (*ProjectsLocationsService) BatchTranslateText

                                                                                                                                                                                                                                            func (r *ProjectsLocationsService) BatchTranslateText(parent string, batchtranslatetextrequest *BatchTranslateTextRequest) *ProjectsLocationsBatchTranslateTextCall

                                                                                                                                                                                                                                              BatchTranslateText: Translates a large volume of text in asynchronous batch mode. This function provides real-time output as the inputs are being processed. If caller cancels a request, the partial results (for an input file, it's all or nothing) may still be available on the specified output location.

                                                                                                                                                                                                                                              This call returns immediately and you can use google.longrunning.Operation.name to poll the status of the call.

                                                                                                                                                                                                                                              func (*ProjectsLocationsService) DetectLanguage

                                                                                                                                                                                                                                              func (r *ProjectsLocationsService) DetectLanguage(parent string, detectlanguagerequest *DetectLanguageRequest) *ProjectsLocationsDetectLanguageCall

                                                                                                                                                                                                                                                DetectLanguage: Detects the language of text within a request.

                                                                                                                                                                                                                                                func (*ProjectsLocationsService) Get

                                                                                                                                                                                                                                                  Get: Gets information about a location.

                                                                                                                                                                                                                                                  func (*ProjectsLocationsService) GetSupportedLanguages

                                                                                                                                                                                                                                                    GetSupportedLanguages: Returns a list of supported languages for translation.

                                                                                                                                                                                                                                                    func (*ProjectsLocationsService) List

                                                                                                                                                                                                                                                      List: Lists information about the supported locations for this service.

                                                                                                                                                                                                                                                      func (*ProjectsLocationsService) TranslateText

                                                                                                                                                                                                                                                      func (r *ProjectsLocationsService) TranslateText(parent string, translatetextrequest *TranslateTextRequest) *ProjectsLocationsTranslateTextCall

                                                                                                                                                                                                                                                        TranslateText: Translates input text and returns translated text.

                                                                                                                                                                                                                                                        type ProjectsLocationsTranslateTextCall

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

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

                                                                                                                                                                                                                                                            Do executes the "translate.projects.locations.translateText" call. Exactly one of *TranslateTextResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *TranslateTextResponse.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 (*ProjectsLocationsTranslateTextCall) Fields

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

                                                                                                                                                                                                                                                              func (*ProjectsLocationsTranslateTextCall) Header

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

                                                                                                                                                                                                                                                                type ProjectsService

                                                                                                                                                                                                                                                                type ProjectsService struct {
                                                                                                                                                                                                                                                                	Locations *ProjectsLocationsService
                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                func NewProjectsService

                                                                                                                                                                                                                                                                func NewProjectsService(s *Service) *ProjectsService

                                                                                                                                                                                                                                                                func (*ProjectsService) DetectLanguage

                                                                                                                                                                                                                                                                func (r *ProjectsService) DetectLanguage(parent string, detectlanguagerequest *DetectLanguageRequest) *ProjectsDetectLanguageCall

                                                                                                                                                                                                                                                                  DetectLanguage: Detects the language of text within a request.

                                                                                                                                                                                                                                                                  func (*ProjectsService) GetSupportedLanguages

                                                                                                                                                                                                                                                                  func (r *ProjectsService) GetSupportedLanguages(parent string) *ProjectsGetSupportedLanguagesCall

                                                                                                                                                                                                                                                                    GetSupportedLanguages: Returns a list of supported languages for translation.

                                                                                                                                                                                                                                                                    func (*ProjectsService) TranslateText

                                                                                                                                                                                                                                                                    func (r *ProjectsService) TranslateText(parent string, translatetextrequest *TranslateTextRequest) *ProjectsTranslateTextCall

                                                                                                                                                                                                                                                                      TranslateText: Translates input text and returns translated text.

                                                                                                                                                                                                                                                                      type ProjectsTranslateTextCall

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

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

                                                                                                                                                                                                                                                                          Do executes the "translate.projects.translateText" call. Exactly one of *TranslateTextResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *TranslateTextResponse.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 (*ProjectsTranslateTextCall) Fields

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

                                                                                                                                                                                                                                                                            func (*ProjectsTranslateTextCall) Header

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

                                                                                                                                                                                                                                                                              type Service

                                                                                                                                                                                                                                                                              type Service struct {
                                                                                                                                                                                                                                                                              	BasePath  string // API endpoint base URL
                                                                                                                                                                                                                                                                              	UserAgent string // optional additional User-Agent fragment
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	Projects *ProjectsService
                                                                                                                                                                                                                                                                              	// 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 SupportedLanguage

                                                                                                                                                                                                                                                                                    type SupportedLanguage struct {
                                                                                                                                                                                                                                                                                    	// DisplayName: Human readable name of the language localized in the
                                                                                                                                                                                                                                                                                    	// display language
                                                                                                                                                                                                                                                                                    	// specified in the request.
                                                                                                                                                                                                                                                                                    	DisplayName string `json:"displayName,omitempty"`
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// LanguageCode: Supported language code, generally consisting of its
                                                                                                                                                                                                                                                                                    	// ISO 639-1
                                                                                                                                                                                                                                                                                    	// identifier, for example, 'en', 'ja'. In certain cases, BCP-47
                                                                                                                                                                                                                                                                                    	// codes
                                                                                                                                                                                                                                                                                    	// including language and region identifiers are returned (for
                                                                                                                                                                                                                                                                                    	// example,
                                                                                                                                                                                                                                                                                    	// 'zh-TW' and 'zh-CN')
                                                                                                                                                                                                                                                                                    	LanguageCode string `json:"languageCode,omitempty"`
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// SupportSource: Can be used as source language.
                                                                                                                                                                                                                                                                                    	SupportSource bool `json:"supportSource,omitempty"`
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// SupportTarget: Can be used as target language.
                                                                                                                                                                                                                                                                                    	SupportTarget bool `json:"supportTarget,omitempty"`
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "DisplayName") 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. "DisplayName") 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:"-"`
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      SupportedLanguage: A single supported language response corresponds to information related to one supported language.

                                                                                                                                                                                                                                                                                      func (*SupportedLanguage) MarshalJSON

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

                                                                                                                                                                                                                                                                                      type SupportedLanguages

                                                                                                                                                                                                                                                                                      type SupportedLanguages struct {
                                                                                                                                                                                                                                                                                      	// Languages: A list of supported language responses. This list contains
                                                                                                                                                                                                                                                                                      	// an entry
                                                                                                                                                                                                                                                                                      	// for each language the Translation API supports.
                                                                                                                                                                                                                                                                                      	Languages []*SupportedLanguage `json:"languages,omitempty"`
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                      	// server.
                                                                                                                                                                                                                                                                                      	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Languages") 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. "Languages") 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:"-"`
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        SupportedLanguages: The response message for discovering supported languages.

                                                                                                                                                                                                                                                                                        func (*SupportedLanguages) MarshalJSON

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

                                                                                                                                                                                                                                                                                        type TranslateTextGlossaryConfig

                                                                                                                                                                                                                                                                                        type TranslateTextGlossaryConfig struct {
                                                                                                                                                                                                                                                                                        	// Glossary: Required. Specifies the glossary used for this translation.
                                                                                                                                                                                                                                                                                        	// Use
                                                                                                                                                                                                                                                                                        	// this format: projects/*/locations/*/glossaries/*
                                                                                                                                                                                                                                                                                        	Glossary string `json:"glossary,omitempty"`
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// IgnoreCase: Optional. Indicates match is case-insensitive.
                                                                                                                                                                                                                                                                                        	// Default value is false if missing.
                                                                                                                                                                                                                                                                                        	IgnoreCase bool `json:"ignoreCase,omitempty"`
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Glossary") 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. "Glossary") 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:"-"`
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          TranslateTextGlossaryConfig: Configures which glossary should be used for a specific target language, and defines options for applying that glossary.

                                                                                                                                                                                                                                                                                          func (*TranslateTextGlossaryConfig) MarshalJSON

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

                                                                                                                                                                                                                                                                                          type TranslateTextRequest

                                                                                                                                                                                                                                                                                          type TranslateTextRequest struct {
                                                                                                                                                                                                                                                                                          	// Contents: Required. The content of the input in string format.
                                                                                                                                                                                                                                                                                          	// We recommend the total content be less than 30k codepoints.
                                                                                                                                                                                                                                                                                          	// Use BatchTranslateText for larger text.
                                                                                                                                                                                                                                                                                          	Contents []string `json:"contents,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// GlossaryConfig: Optional. Glossary to be applied. The glossary must
                                                                                                                                                                                                                                                                                          	// be
                                                                                                                                                                                                                                                                                          	// within the same region (have the same location-id) as the model,
                                                                                                                                                                                                                                                                                          	// otherwise
                                                                                                                                                                                                                                                                                          	// an INVALID_ARGUMENT (400) error is returned.
                                                                                                                                                                                                                                                                                          	GlossaryConfig *TranslateTextGlossaryConfig `json:"glossaryConfig,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// Labels: Optional. The labels with user-defined metadata for the
                                                                                                                                                                                                                                                                                          	// request.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// Label keys and values can be no longer than 63 characters
                                                                                                                                                                                                                                                                                          	// (Unicode codepoints), can only contain lowercase letters,
                                                                                                                                                                                                                                                                                          	// numeric
                                                                                                                                                                                                                                                                                          	// characters, underscores and dashes. International characters are
                                                                                                                                                                                                                                                                                          	// allowed.
                                                                                                                                                                                                                                                                                          	// Label values are optional. Label keys must start with a letter.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// See https://cloud.google.com/translate/docs/labels for more
                                                                                                                                                                                                                                                                                          	// information.
                                                                                                                                                                                                                                                                                          	Labels map[string]string `json:"labels,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// MimeType: Optional. The format of the source text, for example,
                                                                                                                                                                                                                                                                                          	// "text/html",
                                                                                                                                                                                                                                                                                          	//  "text/plain". If left blank, the MIME type defaults to "text/html".
                                                                                                                                                                                                                                                                                          	MimeType string `json:"mimeType,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// Model: Optional. The `model` type requested for this
                                                                                                                                                                                                                                                                                          	// translation.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// The format depends on model type:
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// - AutoML Translation models:
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// `projects/{project-number-or-id}/locations/{location-id}/models/{model
                                                                                                                                                                                                                                                                                          	// -id}`
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// - General (built-in) models:
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// `projects/{project-number-or-id}/locations/{location-id}/models/genera
                                                                                                                                                                                                                                                                                          	// l/nmt`,
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// `projects/{project-number-or-id}/locations/{location-id}/models/genera
                                                                                                                                                                                                                                                                                          	// l/base`
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// For global (non-regionalized) requests, use `location-id`
                                                                                                                                                                                                                                                                                          	// `global`.
                                                                                                                                                                                                                                                                                          	// For
                                                                                                                                                                                                                                                                                          	// example,
                                                                                                                                                                                                                                                                                          	// `projects/{project-number-or-id}/locations/global/models/gene
                                                                                                                                                                                                                                                                                          	// ral/nmt`.
                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                          	// If missing, the system decides which google base model to use.
                                                                                                                                                                                                                                                                                          	Model string `json:"model,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// SourceLanguageCode: Optional. The BCP-47 language code of the input
                                                                                                                                                                                                                                                                                          	// text if
                                                                                                                                                                                                                                                                                          	// known, for example, "en-US" or "sr-Latn". Supported language codes
                                                                                                                                                                                                                                                                                          	// are
                                                                                                                                                                                                                                                                                          	// listed in Language Support. If the source language isn't specified,
                                                                                                                                                                                                                                                                                          	// the API
                                                                                                                                                                                                                                                                                          	// attempts to identify the source language automatically and returns
                                                                                                                                                                                                                                                                                          	// the
                                                                                                                                                                                                                                                                                          	// source language within the response.
                                                                                                                                                                                                                                                                                          	SourceLanguageCode string `json:"sourceLanguageCode,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// TargetLanguageCode: Required. The BCP-47 language code to use for
                                                                                                                                                                                                                                                                                          	// translation of the input
                                                                                                                                                                                                                                                                                          	// text, set to one of the language codes listed in Language Support.
                                                                                                                                                                                                                                                                                          	TargetLanguageCode string `json:"targetLanguageCode,omitempty"`
                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Contents") 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. "Contents") 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:"-"`
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            TranslateTextRequest: The request message for synchronous translation.

                                                                                                                                                                                                                                                                                            func (*TranslateTextRequest) MarshalJSON

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

                                                                                                                                                                                                                                                                                            type TranslateTextResponse

                                                                                                                                                                                                                                                                                            type TranslateTextResponse struct {
                                                                                                                                                                                                                                                                                            	// GlossaryTranslations: Text translation responses if a glossary is
                                                                                                                                                                                                                                                                                            	// provided in the request.
                                                                                                                                                                                                                                                                                            	// This can be the same as
                                                                                                                                                                                                                                                                                            	// `translations` if no terms apply.
                                                                                                                                                                                                                                                                                            	// This field has the same length as
                                                                                                                                                                                                                                                                                            	// `contents`.
                                                                                                                                                                                                                                                                                            	GlossaryTranslations []*Translation `json:"glossaryTranslations,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// Translations: Text translation responses with no glossary
                                                                                                                                                                                                                                                                                            	// applied.
                                                                                                                                                                                                                                                                                            	// This field has the same length as
                                                                                                                                                                                                                                                                                            	// `contents`.
                                                                                                                                                                                                                                                                                            	Translations []*Translation `json:"translations,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                            	// server.
                                                                                                                                                                                                                                                                                            	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g.
                                                                                                                                                                                                                                                                                            	// "GlossaryTranslations") 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. "GlossaryTranslations") to
                                                                                                                                                                                                                                                                                            	// include in API requests with the JSON null value. By default, fields
                                                                                                                                                                                                                                                                                            	// with empty values are omitted from API requests. However, any field
                                                                                                                                                                                                                                                                                            	// with an empty value appearing in NullFields will be sent to the
                                                                                                                                                                                                                                                                                            	// server as null. It is an error if a field in this list has a
                                                                                                                                                                                                                                                                                            	// non-empty value. This may be used to include null fields in Patch
                                                                                                                                                                                                                                                                                            	// requests.
                                                                                                                                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                            func (*TranslateTextResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                            type Translation

                                                                                                                                                                                                                                                                                            type Translation struct {
                                                                                                                                                                                                                                                                                            	// DetectedLanguageCode: The BCP-47 language code of source text in the
                                                                                                                                                                                                                                                                                            	// initial request, detected
                                                                                                                                                                                                                                                                                            	// automatically, if no source language was passed within the
                                                                                                                                                                                                                                                                                            	// initial
                                                                                                                                                                                                                                                                                            	// request. If the source language was passed, auto-detection of the
                                                                                                                                                                                                                                                                                            	// language
                                                                                                                                                                                                                                                                                            	// does not occur and this field is empty.
                                                                                                                                                                                                                                                                                            	DetectedLanguageCode string `json:"detectedLanguageCode,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// GlossaryConfig: The `glossary_config` used for this translation.
                                                                                                                                                                                                                                                                                            	GlossaryConfig *TranslateTextGlossaryConfig `json:"glossaryConfig,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// Model: Only present when `model` is present in the request.
                                                                                                                                                                                                                                                                                            	// `model` here is normalized to have project number.
                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                            	// For example:
                                                                                                                                                                                                                                                                                            	// If the `model` requested in TranslationTextRequest
                                                                                                                                                                                                                                                                                            	// is
                                                                                                                                                                                                                                                                                            	// `projects/{project-id}/locations/{location-id}/models/general/nmt`
                                                                                                                                                                                                                                                                                            	// then
                                                                                                                                                                                                                                                                                            	// `model` here would be normalized
                                                                                                                                                                                                                                                                                            	// to
                                                                                                                                                                                                                                                                                            	// `projects/{project-number}/locations/{location-id}/models/general/n
                                                                                                                                                                                                                                                                                            	// mt`.
                                                                                                                                                                                                                                                                                            	Model string `json:"model,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// TranslatedText: Text translated into the target language.
                                                                                                                                                                                                                                                                                            	TranslatedText string `json:"translatedText,omitempty"`
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g.
                                                                                                                                                                                                                                                                                            	// "DetectedLanguageCode") 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. "DetectedLanguageCode") 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:"-"`
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              Translation: A single translation response.

                                                                                                                                                                                                                                                                                              func (*Translation) MarshalJSON

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

                                                                                                                                                                                                                                                                                              type WaitOperationRequest

                                                                                                                                                                                                                                                                                              type WaitOperationRequest struct {
                                                                                                                                                                                                                                                                                              	// Timeout: The maximum duration to wait before timing out. If left
                                                                                                                                                                                                                                                                                              	// blank, the wait
                                                                                                                                                                                                                                                                                              	// will be at most the time permitted by the underlying HTTP/RPC
                                                                                                                                                                                                                                                                                              	// protocol.
                                                                                                                                                                                                                                                                                              	// If RPC context deadline is also specified, the shorter one will be
                                                                                                                                                                                                                                                                                              	// used.
                                                                                                                                                                                                                                                                                              	Timeout string `json:"timeout,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Timeout") 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. "Timeout") 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:"-"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                WaitOperationRequest: The request message for Operations.WaitOperation.

                                                                                                                                                                                                                                                                                                func (*WaitOperationRequest) MarshalJSON

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