Documentation

Overview

Package vision provides access to the Cloud Vision API.

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

For product documentation, see: https://cloud.google.com/vision/

Creating a client

Usage example:

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

visionService, err := vision.NewService(ctx, option.WithScopes(vision.CloudVisionScope))

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

visionService, err := vision.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, ...)
visionService, err := vision.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"

	// Apply machine learning models to understand and label images
	CloudVisionScope = "https://www.googleapis.com/auth/cloud-vision"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AddProductToProductSetRequest

    type AddProductToProductSetRequest struct {
    	// Product: Required. The resource name for the Product to be added to
    	// this ProductSet.
    	//
    	// Format is:
    	// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`
    	Product string `json:"product,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "Product") 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. "Product") 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:"-"`
    }

      AddProductToProductSetRequest: Request message for the `AddProductToProductSet` method.

      func (*AddProductToProductSetRequest) MarshalJSON

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

      type AnnotateFileRequest

      type AnnotateFileRequest struct {
      	// Features: Required. Requested features.
      	Features []*Feature `json:"features,omitempty"`
      
      	// ImageContext: Additional context that may accompany the image(s) in
      	// the file.
      	ImageContext *ImageContext `json:"imageContext,omitempty"`
      
      	// InputConfig: Required. Information about the input file.
      	InputConfig *InputConfig `json:"inputConfig,omitempty"`
      
      	// Pages: Pages of the file to perform image annotation.
      	//
      	// Pages starts from 1, we assume the first page of the file is page
      	// 1.
      	// At most 5 pages are supported per request. Pages can be
      	// negative.
      	//
      	// Page 1 means the first page.
      	// Page 2 means the second page.
      	// Page -1 means the last page.
      	// Page -2 means the second to the last page.
      	//
      	// If the file is GIF instead of PDF or TIFF, page refers to GIF
      	// frames.
      	//
      	// If this field is empty, by default the service performs image
      	// annotation
      	// for the first 5 pages of the file.
      	Pages []int64 `json:"pages,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g. "Features") 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. "Features") 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:"-"`
      }

        AnnotateFileRequest: A request to annotate one single file, e.g. a PDF, TIFF or GIF file.

        func (*AnnotateFileRequest) MarshalJSON

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

        type AnnotateFileResponse

        type AnnotateFileResponse struct {
        	// Error: If set, represents the error message for the failed request.
        	// The
        	// `responses` field will not be set in this case.
        	Error *Status `json:"error,omitempty"`
        
        	// InputConfig: Information about the file for which this response is
        	// generated.
        	InputConfig *InputConfig `json:"inputConfig,omitempty"`
        
        	// Responses: Individual responses to images found within the file. This
        	// field will be
        	// empty if the `error` field is set.
        	Responses []*AnnotateImageResponse `json:"responses,omitempty"`
        
        	// TotalPages: This field gives the total number of pages in the file.
        	TotalPages int64 `json:"totalPages,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "Error") 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. "Error") 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:"-"`
        }

          AnnotateFileResponse: Response to a single file annotation request. A file may contain one or more images, which individually have their own responses.

          func (*AnnotateFileResponse) MarshalJSON

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

          type AnnotateImageRequest

          type AnnotateImageRequest struct {
          	// Features: Requested features.
          	Features []*Feature `json:"features,omitempty"`
          
          	// Image: The image to be processed.
          	Image *Image `json:"image,omitempty"`
          
          	// ImageContext: Additional context that may accompany the image.
          	ImageContext *ImageContext `json:"imageContext,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Features") 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. "Features") 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:"-"`
          }

            AnnotateImageRequest: Request for performing Google Cloud Vision API tasks over a user-provided image, with user-requested features, and with context information.

            func (*AnnotateImageRequest) MarshalJSON

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

            type AnnotateImageResponse

            type AnnotateImageResponse struct {
            	// Context: If present, contextual information is needed to understand
            	// where this image
            	// comes from.
            	Context *ImageAnnotationContext `json:"context,omitempty"`
            
            	// CropHintsAnnotation: If present, crop hints have completed
            	// successfully.
            	CropHintsAnnotation *CropHintsAnnotation `json:"cropHintsAnnotation,omitempty"`
            
            	// Error: If set, represents the error message for the operation.
            	// Note that filled-in image annotations are guaranteed to be
            	// correct, even when `error` is set.
            	Error *Status `json:"error,omitempty"`
            
            	// FaceAnnotations: If present, face detection has completed
            	// successfully.
            	FaceAnnotations []*FaceAnnotation `json:"faceAnnotations,omitempty"`
            
            	// FullTextAnnotation: If present, text (OCR) detection or document
            	// (OCR) text detection has
            	// completed successfully.
            	// This annotation provides the structural hierarchy for the OCR
            	// detected
            	// text.
            	FullTextAnnotation *TextAnnotation `json:"fullTextAnnotation,omitempty"`
            
            	// ImagePropertiesAnnotation: If present, image properties were
            	// extracted successfully.
            	ImagePropertiesAnnotation *ImageProperties `json:"imagePropertiesAnnotation,omitempty"`
            
            	// LabelAnnotations: If present, label detection has completed
            	// successfully.
            	LabelAnnotations []*EntityAnnotation `json:"labelAnnotations,omitempty"`
            
            	// LandmarkAnnotations: If present, landmark detection has completed
            	// successfully.
            	LandmarkAnnotations []*EntityAnnotation `json:"landmarkAnnotations,omitempty"`
            
            	// LocalizedObjectAnnotations: If present, localized object detection
            	// has completed successfully.
            	// This will be sorted descending by confidence score.
            	LocalizedObjectAnnotations []*LocalizedObjectAnnotation `json:"localizedObjectAnnotations,omitempty"`
            
            	// LogoAnnotations: If present, logo detection has completed
            	// successfully.
            	LogoAnnotations []*EntityAnnotation `json:"logoAnnotations,omitempty"`
            
            	// ProductSearchResults: If present, product search has completed
            	// successfully.
            	ProductSearchResults *ProductSearchResults `json:"productSearchResults,omitempty"`
            
            	// SafeSearchAnnotation: If present, safe-search annotation has
            	// completed successfully.
            	SafeSearchAnnotation *SafeSearchAnnotation `json:"safeSearchAnnotation,omitempty"`
            
            	// TextAnnotations: If present, text (OCR) detection has completed
            	// successfully.
            	TextAnnotations []*EntityAnnotation `json:"textAnnotations,omitempty"`
            
            	// WebDetection: If present, web detection has completed successfully.
            	WebDetection *WebDetection `json:"webDetection,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "Context") 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. "Context") 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:"-"`
            }

              AnnotateImageResponse: Response to an image annotation request.

              func (*AnnotateImageResponse) MarshalJSON

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

              type AsyncAnnotateFileRequest

              type AsyncAnnotateFileRequest struct {
              	// Features: Required. Requested features.
              	Features []*Feature `json:"features,omitempty"`
              
              	// ImageContext: Additional context that may accompany the image(s) in
              	// the file.
              	ImageContext *ImageContext `json:"imageContext,omitempty"`
              
              	// InputConfig: Required. Information about the input file.
              	InputConfig *InputConfig `json:"inputConfig,omitempty"`
              
              	// OutputConfig: Required. The desired output location and metadata
              	// (e.g. format).
              	OutputConfig *OutputConfig `json:"outputConfig,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Features") 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. "Features") 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:"-"`
              }

                AsyncAnnotateFileRequest: An offline file annotation request.

                func (*AsyncAnnotateFileRequest) MarshalJSON

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

                type AsyncAnnotateFileResponse

                type AsyncAnnotateFileResponse struct {
                	// OutputConfig: The output location and metadata from
                	// AsyncAnnotateFileRequest.
                	OutputConfig *OutputConfig `json:"outputConfig,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "OutputConfig") 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. "OutputConfig") 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:"-"`
                }

                  AsyncAnnotateFileResponse: The response for a single offline file annotation request.

                  func (*AsyncAnnotateFileResponse) MarshalJSON

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

                  type AsyncBatchAnnotateFilesRequest

                  type AsyncBatchAnnotateFilesRequest struct {
                  	// Parent: Optional. Target project and location to make a
                  	// call.
                  	//
                  	// Format: `projects/{project-id}/locations/{location-id}`.
                  	//
                  	// If no parent is specified, a region will be chosen
                  	// automatically.
                  	//
                  	// Supported location-ids:
                  	//     `us`: USA country only,
                  	//     `asia`: East asia areas, like Japan, Taiwan,
                  	//     `eu`: The European Union.
                  	//
                  	// Example: `projects/project-A/locations/eu`.
                  	Parent string `json:"parent,omitempty"`
                  
                  	// Requests: Required. Individual async file annotation requests for
                  	// this batch.
                  	Requests []*AsyncAnnotateFileRequest `json:"requests,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "Parent") 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. "Parent") 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:"-"`
                  }

                    AsyncBatchAnnotateFilesRequest: Multiple async file annotation requests are batched into a single service call.

                    func (*AsyncBatchAnnotateFilesRequest) MarshalJSON

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

                    type AsyncBatchAnnotateFilesResponse

                    type AsyncBatchAnnotateFilesResponse struct {
                    	// Responses: The list of file annotation responses, one for each
                    	// request in
                    	// AsyncBatchAnnotateFilesRequest.
                    	Responses []*AsyncAnnotateFileResponse `json:"responses,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "Responses") 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. "Responses") 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:"-"`
                    }

                      AsyncBatchAnnotateFilesResponse: Response to an async batch file annotation request.

                      func (*AsyncBatchAnnotateFilesResponse) MarshalJSON

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

                      type AsyncBatchAnnotateImagesRequest

                      type AsyncBatchAnnotateImagesRequest struct {
                      	// OutputConfig: Required. The desired output location and metadata
                      	// (e.g. format).
                      	OutputConfig *OutputConfig `json:"outputConfig,omitempty"`
                      
                      	// Parent: Optional. Target project and location to make a
                      	// call.
                      	//
                      	// Format: `projects/{project-id}/locations/{location-id}`.
                      	//
                      	// If no parent is specified, a region will be chosen
                      	// automatically.
                      	//
                      	// Supported location-ids:
                      	//     `us`: USA country only,
                      	//     `asia`: East asia areas, like Japan, Taiwan,
                      	//     `eu`: The European Union.
                      	//
                      	// Example: `projects/project-A/locations/eu`.
                      	Parent string `json:"parent,omitempty"`
                      
                      	// Requests: Required. Individual image annotation requests for this
                      	// batch.
                      	Requests []*AnnotateImageRequest `json:"requests,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "OutputConfig") 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. "OutputConfig") 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:"-"`
                      }

                        AsyncBatchAnnotateImagesRequest: Request for async image annotation for a list of images.

                        func (*AsyncBatchAnnotateImagesRequest) MarshalJSON

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

                        type AsyncBatchAnnotateImagesResponse

                        type AsyncBatchAnnotateImagesResponse struct {
                        	// OutputConfig: The output location and metadata from
                        	// AsyncBatchAnnotateImagesRequest.
                        	OutputConfig *OutputConfig `json:"outputConfig,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "OutputConfig") 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. "OutputConfig") 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:"-"`
                        }

                          AsyncBatchAnnotateImagesResponse: Response to an async batch image annotation request.

                          func (*AsyncBatchAnnotateImagesResponse) MarshalJSON

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

                          type BatchAnnotateFilesRequest

                          type BatchAnnotateFilesRequest struct {
                          	// Parent: Optional. Target project and location to make a
                          	// call.
                          	//
                          	// Format: `projects/{project-id}/locations/{location-id}`.
                          	//
                          	// If no parent is specified, a region will be chosen
                          	// automatically.
                          	//
                          	// Supported location-ids:
                          	//     `us`: USA country only,
                          	//     `asia`: East asia areas, like Japan, Taiwan,
                          	//     `eu`: The European Union.
                          	//
                          	// Example: `projects/project-A/locations/eu`.
                          	Parent string `json:"parent,omitempty"`
                          
                          	// Requests: Required. The list of file annotation requests. Right now
                          	// we support only one
                          	// AnnotateFileRequest in BatchAnnotateFilesRequest.
                          	Requests []*AnnotateFileRequest `json:"requests,omitempty"`
                          
                          	// ForceSendFields is a list of field names (e.g. "Parent") 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. "Parent") 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:"-"`
                          }

                            BatchAnnotateFilesRequest: A list of requests to annotate files using the BatchAnnotateFiles API.

                            func (*BatchAnnotateFilesRequest) MarshalJSON

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

                            type BatchAnnotateFilesResponse

                            type BatchAnnotateFilesResponse struct {
                            	// Responses: The list of file annotation responses, each response
                            	// corresponding to each
                            	// AnnotateFileRequest in BatchAnnotateFilesRequest.
                            	Responses []*AnnotateFileResponse `json:"responses,omitempty"`
                            
                            	// ServerResponse contains the HTTP response code and headers from the
                            	// server.
                            	googleapi.ServerResponse `json:"-"`
                            
                            	// ForceSendFields is a list of field names (e.g. "Responses") 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. "Responses") 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:"-"`
                            }

                              BatchAnnotateFilesResponse: A list of file annotation responses.

                              func (*BatchAnnotateFilesResponse) MarshalJSON

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

                              type BatchAnnotateImagesRequest

                              type BatchAnnotateImagesRequest struct {
                              	// Parent: Optional. Target project and location to make a
                              	// call.
                              	//
                              	// Format: `projects/{project-id}/locations/{location-id}`.
                              	//
                              	// If no parent is specified, a region will be chosen
                              	// automatically.
                              	//
                              	// Supported location-ids:
                              	//     `us`: USA country only,
                              	//     `asia`: East asia areas, like Japan, Taiwan,
                              	//     `eu`: The European Union.
                              	//
                              	// Example: `projects/project-A/locations/eu`.
                              	Parent string `json:"parent,omitempty"`
                              
                              	// Requests: Required. Individual image annotation requests for this
                              	// batch.
                              	Requests []*AnnotateImageRequest `json:"requests,omitempty"`
                              
                              	// ForceSendFields is a list of field names (e.g. "Parent") 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. "Parent") 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:"-"`
                              }

                                BatchAnnotateImagesRequest: Multiple image annotation requests are batched into a single service call.

                                func (*BatchAnnotateImagesRequest) MarshalJSON

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

                                type BatchAnnotateImagesResponse

                                type BatchAnnotateImagesResponse struct {
                                	// Responses: Individual responses to image annotation requests within
                                	// the batch.
                                	Responses []*AnnotateImageResponse `json:"responses,omitempty"`
                                
                                	// ServerResponse contains the HTTP response code and headers from the
                                	// server.
                                	googleapi.ServerResponse `json:"-"`
                                
                                	// ForceSendFields is a list of field names (e.g. "Responses") 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. "Responses") 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:"-"`
                                }

                                  BatchAnnotateImagesResponse: Response to a batch image annotation request.

                                  func (*BatchAnnotateImagesResponse) MarshalJSON

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

                                  type BatchOperationMetadata

                                  type BatchOperationMetadata struct {
                                  	// EndTime: The time when the batch request is finished
                                  	// and
                                  	// google.longrunning.Operation.done is set to true.
                                  	EndTime string `json:"endTime,omitempty"`
                                  
                                  	// State: The current state of the batch operation.
                                  	//
                                  	// Possible values:
                                  	//   "STATE_UNSPECIFIED" - Invalid.
                                  	//   "PROCESSING" - Request is actively being processed.
                                  	//   "SUCCESSFUL" - The request is done and at least one item has been
                                  	// successfully
                                  	// processed.
                                  	//   "FAILED" - The request is done and no item has been successfully
                                  	// processed.
                                  	//   "CANCELLED" - The request is done after the
                                  	// longrunning.Operations.CancelOperation has
                                  	// been called by the user.  Any records that were processed before
                                  	// the
                                  	// cancel command are output as specified in the request.
                                  	State string `json:"state,omitempty"`
                                  
                                  	// SubmitTime: The time when the batch request was submitted to the
                                  	// server.
                                  	SubmitTime string `json:"submitTime,omitempty"`
                                  
                                  	// 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:"-"`
                                  }

                                    BatchOperationMetadata: Metadata for the batch operations such as the current state.

                                    This is included in the `metadata` field of the `Operation` returned by the `GetOperation` call of the `google::longrunning::Operations` service.

                                    func (*BatchOperationMetadata) MarshalJSON

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

                                    type Block

                                    type Block struct {
                                    	// BlockType: Detected block type (text, image etc) for this block.
                                    	//
                                    	// Possible values:
                                    	//   "UNKNOWN" - Unknown block type.
                                    	//   "TEXT" - Regular text block.
                                    	//   "TABLE" - Table block.
                                    	//   "PICTURE" - Image block.
                                    	//   "RULER" - Horizontal/vertical line box.
                                    	//   "BARCODE" - Barcode block.
                                    	BlockType string `json:"blockType,omitempty"`
                                    
                                    	// BoundingBox: The bounding box for the block.
                                    	// The vertices are in the order of top-left, top-right,
                                    	// bottom-right,
                                    	// bottom-left. When a rotation of the bounding box is detected the
                                    	// rotation
                                    	// is represented as around the top-left corner as defined when the text
                                    	// is
                                    	// read in the 'natural' orientation.
                                    	// For example:
                                    	//
                                    	// * when the text is horizontal it might look like:
                                    	//
                                    	//         0----1
                                    	//         |    |
                                    	//         3----2
                                    	//
                                    	// * when it's rotated 180 degrees around the top-left corner it
                                    	// becomes:
                                    	//
                                    	//         2----3
                                    	//         |    |
                                    	//         1----0
                                    	//
                                    	//   and the vertex order will still be (0, 1, 2, 3).
                                    	BoundingBox *BoundingPoly `json:"boundingBox,omitempty"`
                                    
                                    	// Confidence: Confidence of the OCR results on the block. Range [0, 1].
                                    	Confidence float64 `json:"confidence,omitempty"`
                                    
                                    	// Paragraphs: List of paragraphs in this block (if this blocks is of
                                    	// type text).
                                    	Paragraphs []*Paragraph `json:"paragraphs,omitempty"`
                                    
                                    	// Property: Additional information detected for the block.
                                    	Property *TextProperty `json:"property,omitempty"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "BlockType") 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. "BlockType") 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:"-"`
                                    }

                                      Block: Logical element on the page.

                                      func (*Block) MarshalJSON

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

                                      func (*Block) UnmarshalJSON

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

                                      type BoundingPoly

                                      type BoundingPoly struct {
                                      	// NormalizedVertices: The bounding polygon normalized vertices.
                                      	NormalizedVertices []*NormalizedVertex `json:"normalizedVertices,omitempty"`
                                      
                                      	// Vertices: The bounding polygon vertices.
                                      	Vertices []*Vertex `json:"vertices,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "NormalizedVertices")
                                      	// 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. "NormalizedVertices") 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:"-"`
                                      }

                                        BoundingPoly: A bounding polygon for the detected image annotation.

                                        func (*BoundingPoly) MarshalJSON

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

                                        type CancelOperationRequest

                                        type CancelOperationRequest struct {
                                        }

                                          CancelOperationRequest: The request message for Operations.CancelOperation.

                                          type Color

                                          type Color struct {
                                          	// Alpha: The fraction of this color that should be applied to the
                                          	// pixel. That is,
                                          	// the final pixel color is defined by the equation:
                                          	//
                                          	//   pixel color = alpha * (this color) + (1.0 - alpha) * (background
                                          	// color)
                                          	//
                                          	// This means that a value of 1.0 corresponds to a solid color,
                                          	// whereas
                                          	// a value of 0.0 corresponds to a completely transparent color.
                                          	// This
                                          	// uses a wrapper message rather than a simple float scalar so that it
                                          	// is
                                          	// possible to distinguish between a default value and the value being
                                          	// unset.
                                          	// If omitted, this color object is to be rendered as a solid color
                                          	// (as if the alpha value had been explicitly given with a value of
                                          	// 1.0).
                                          	Alpha float64 `json:"alpha,omitempty"`
                                          
                                          	// Blue: The amount of blue in the color as a value in the interval [0,
                                          	// 1].
                                          	Blue float64 `json:"blue,omitempty"`
                                          
                                          	// Green: The amount of green in the color as a value in the interval
                                          	// [0, 1].
                                          	Green float64 `json:"green,omitempty"`
                                          
                                          	// Red: The amount of red in the color as a value in the interval [0,
                                          	// 1].
                                          	Red float64 `json:"red,omitempty"`
                                          
                                          	// ForceSendFields is a list of field names (e.g. "Alpha") 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. "Alpha") 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:"-"`
                                          }

                                            Color: Represents a color in the RGBA color space. This representation is designed for simplicity of conversion to/from color representations in various languages over compactness; for example, the fields of this representation can be trivially provided to the constructor of "java.awt.Color" in Java; it can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha" method in iOS; and, with just a little work, it can be easily formatted into a CSS "rgba()" string in JavaScript, as well.

                                            Note: this proto does not carry information about the absolute color space that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB, DCI-P3, BT.2020, etc.). By default, applications SHOULD assume the sRGB color space.

                                            Example (Java):

                                            import com.google.type.Color;
                                            
                                            // ...
                                            public static java.awt.Color fromProto(Color protocolor) {
                                              float alpha = protocolor.hasAlpha()
                                                  ? protocolor.getAlpha().getValue()
                                                  : 1.0;
                                            
                                              return new java.awt.Color(
                                                  protocolor.getRed(),
                                                  protocolor.getGreen(),
                                                  protocolor.getBlue(),
                                                  alpha);
                                            }
                                            
                                            public static Color toProto(java.awt.Color color) {
                                              float red = (float) color.getRed();
                                              float green = (float) color.getGreen();
                                              float blue = (float) color.getBlue();
                                              float denominator = 255.0;
                                              Color.Builder resultBuilder =
                                                  Color
                                                      .newBuilder()
                                                      .setRed(red / denominator)
                                                      .setGreen(green / denominator)
                                                      .setBlue(blue / denominator);
                                              int alpha = color.getAlpha();
                                              if (alpha != 255) {
                                                result.setAlpha(
                                                    FloatValue
                                                        .newBuilder()
                                                        .setValue(((float) alpha) / denominator)
                                                        .build());
                                              }
                                              return resultBuilder.build();
                                            }
                                            // ...
                                            

                                            Example (iOS / Obj-C):

                                            // ...
                                            static UIColor* fromProto(Color* protocolor) {
                                               float red = [protocolor red];
                                               float green = [protocolor green];
                                               float blue = [protocolor blue];
                                               FloatValue* alpha_wrapper = [protocolor alpha];
                                               float alpha = 1.0;
                                               if (alpha_wrapper != nil) {
                                                 alpha = [alpha_wrapper value];
                                               }
                                               return [UIColor colorWithRed:red green:green blue:blue
                                            

                                            alpha:alpha];

                                            }
                                            
                                            static Color* toProto(UIColor* color) {
                                                CGFloat red, green, blue, alpha;
                                                if (![color getRed:&red green:&green blue:&blue
                                            

                                            alpha:&alpha]) {

                                                      return nil;
                                                    }
                                                    Color* result = [[Color alloc] init];
                                                    [result setRed:red];
                                                    [result setGreen:green];
                                                    [result setBlue:blue];
                                                    if (alpha <= 0.9999) {
                                                      [result setAlpha:floatWrapperWithValue(alpha)];
                                                    }
                                                    [result autorelease];
                                                    return result;
                                               }
                                               // ...
                                            
                                            Example (JavaScript):
                                            
                                               // ...
                                            
                                               var protoToCssColor = function(rgb_color) {
                                                  var redFrac = rgb_color.red || 0.0;
                                                  var greenFrac = rgb_color.green || 0.0;
                                                  var blueFrac = rgb_color.blue || 0.0;
                                                  var red = Math.floor(redFrac * 255);
                                                  var green = Math.floor(greenFrac * 255);
                                                  var blue = Math.floor(blueFrac * 255);
                                            
                                                  if (!('alpha' in rgb_color)) {
                                                     return rgbToCssColor_(red, green, blue);
                                                  }
                                            
                                                  var alphaFrac = rgb_color.alpha.value || 0.0;
                                                  var rgbParams = [red, green, blue].join(',');
                                                  return ['rgba(', rgbParams, ',', alphaFrac, ')'].join(”);
                                               };
                                            
                                               var rgbToCssColor_ = function(red, green, blue) {
                                                 var rgbNumber = new Number((red << 16) | (green << 8) | blue);
                                                 var hexString = rgbNumber.toString(16);
                                                 var missingZeros = 6 - hexString.length;
                                                 var resultBuilder = ['#'];
                                                 for (var i = 0; i < missingZeros; i++) {
                                                    resultBuilder.push('0');
                                                 }
                                                 resultBuilder.push(hexString);
                                                 return resultBuilder.join(”);
                                               };
                                            
                                               // ...
                                            

                                            func (*Color) MarshalJSON

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

                                            func (*Color) UnmarshalJSON

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

                                            type ColorInfo

                                            type ColorInfo struct {
                                            	// Color: RGB components of the color.
                                            	Color *Color `json:"color,omitempty"`
                                            
                                            	// PixelFraction: The fraction of pixels the color occupies in the
                                            	// image.
                                            	// Value in range [0, 1].
                                            	PixelFraction float64 `json:"pixelFraction,omitempty"`
                                            
                                            	// Score: Image-specific score for this color. Value in range [0, 1].
                                            	Score float64 `json:"score,omitempty"`
                                            
                                            	// ForceSendFields is a list of field names (e.g. "Color") 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. "Color") 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:"-"`
                                            }

                                              ColorInfo: Color information consists of RGB channels, score, and the fraction of the image that the color occupies in the image.

                                              func (*ColorInfo) MarshalJSON

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

                                              func (*ColorInfo) UnmarshalJSON

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

                                              type CropHint

                                              type CropHint struct {
                                              	// BoundingPoly: The bounding polygon for the crop region. The
                                              	// coordinates of the bounding
                                              	// box are in the original image's scale.
                                              	BoundingPoly *BoundingPoly `json:"boundingPoly,omitempty"`
                                              
                                              	// Confidence: Confidence of this being a salient region.  Range [0, 1].
                                              	Confidence float64 `json:"confidence,omitempty"`
                                              
                                              	// ImportanceFraction: Fraction of importance of this salient region
                                              	// with respect to the original
                                              	// image.
                                              	ImportanceFraction float64 `json:"importanceFraction,omitempty"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "BoundingPoly") 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. "BoundingPoly") 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:"-"`
                                              }

                                                CropHint: Single crop hint that is used to generate a new crop when serving an image.

                                                func (*CropHint) MarshalJSON

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

                                                func (*CropHint) UnmarshalJSON

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

                                                type CropHintsAnnotation

                                                type CropHintsAnnotation struct {
                                                	// CropHints: Crop hint results.
                                                	CropHints []*CropHint `json:"cropHints,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "CropHints") 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. "CropHints") 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:"-"`
                                                }

                                                  CropHintsAnnotation: Set of crop hints that are used to generate new crops when serving images.

                                                  func (*CropHintsAnnotation) MarshalJSON

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

                                                  type CropHintsParams

                                                  type CropHintsParams struct {
                                                  	// AspectRatios: Aspect ratios in floats, representing the ratio of the
                                                  	// width to the height
                                                  	// of the image. For example, if the desired aspect ratio is 4/3,
                                                  	// the
                                                  	// corresponding float value should be 1.33333.  If not specified,
                                                  	// the
                                                  	// best possible crop is returned. The number of provided aspect ratios
                                                  	// is
                                                  	// limited to a maximum of 16; any aspect ratios provided after the 16th
                                                  	// are
                                                  	// ignored.
                                                  	AspectRatios []float64 `json:"aspectRatios,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "AspectRatios") 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. "AspectRatios") 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:"-"`
                                                  }

                                                    CropHintsParams: Parameters for crop hints annotation request.

                                                    func (*CropHintsParams) MarshalJSON

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

                                                    type DetectedBreak

                                                    type DetectedBreak struct {
                                                    	// IsPrefix: True if break prepends the element.
                                                    	IsPrefix bool `json:"isPrefix,omitempty"`
                                                    
                                                    	// Type: Detected break type.
                                                    	//
                                                    	// Possible values:
                                                    	//   "UNKNOWN" - Unknown break label type.
                                                    	//   "SPACE" - Regular space.
                                                    	//   "SURE_SPACE" - Sure space (very wide).
                                                    	//   "EOL_SURE_SPACE" - Line-wrapping break.
                                                    	//   "HYPHEN" - End-line hyphen that is not present in text; does not
                                                    	// co-occur with
                                                    	// `SPACE`, `LEADER_SPACE`, or `LINE_BREAK`.
                                                    	//   "LINE_BREAK" - Line break that ends a paragraph.
                                                    	Type string `json:"type,omitempty"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "IsPrefix") 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. "IsPrefix") 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:"-"`
                                                    }

                                                      DetectedBreak: Detected start or end of a structural component.

                                                      func (*DetectedBreak) MarshalJSON

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

                                                      type DetectedLanguage

                                                      type DetectedLanguage struct {
                                                      	// Confidence: Confidence of detected language. Range [0, 1].
                                                      	Confidence float64 `json:"confidence,omitempty"`
                                                      
                                                      	// LanguageCode: The BCP-47 language code, such as "en-US" or "sr-Latn".
                                                      	// For more
                                                      	// information,
                                                      	// see
                                                      	// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
                                                      	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: Detected language for a structural component.

                                                        func (*DetectedLanguage) MarshalJSON

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

                                                        func (*DetectedLanguage) UnmarshalJSON

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

                                                        type DominantColorsAnnotation

                                                        type DominantColorsAnnotation struct {
                                                        	// Colors: RGB color values with their score and pixel fraction.
                                                        	Colors []*ColorInfo `json:"colors,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "Colors") 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. "Colors") 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:"-"`
                                                        }

                                                          DominantColorsAnnotation: Set of dominant colors and their corresponding scores.

                                                          func (*DominantColorsAnnotation) MarshalJSON

                                                          func (s *DominantColorsAnnotation) MarshalJSON() ([]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 EntityAnnotation

                                                            type EntityAnnotation struct {
                                                            	// BoundingPoly: Image region to which this entity belongs. Not
                                                            	// produced
                                                            	// for `LABEL_DETECTION` features.
                                                            	BoundingPoly *BoundingPoly `json:"boundingPoly,omitempty"`
                                                            
                                                            	// Confidence: **Deprecated. Use `score` instead.**
                                                            	// The accuracy of the entity detection in an image.
                                                            	// For example, for an image in which the "Eiffel Tower" entity is
                                                            	// detected,
                                                            	// this field represents the confidence that there is a tower in the
                                                            	// query
                                                            	// image. Range [0, 1].
                                                            	Confidence float64 `json:"confidence,omitempty"`
                                                            
                                                            	// Description: Entity textual description, expressed in its `locale`
                                                            	// language.
                                                            	Description string `json:"description,omitempty"`
                                                            
                                                            	// Locale: The language code for the locale in which the entity
                                                            	// textual
                                                            	// `description` is expressed.
                                                            	Locale string `json:"locale,omitempty"`
                                                            
                                                            	// Locations: The location information for the detected entity.
                                                            	// Multiple
                                                            	// `LocationInfo` elements can be present because one location
                                                            	// may
                                                            	// indicate the location of the scene in the image, and another
                                                            	// location
                                                            	// may indicate the location of the place where the image was
                                                            	// taken.
                                                            	// Location information is usually present for landmarks.
                                                            	Locations []*LocationInfo `json:"locations,omitempty"`
                                                            
                                                            	// Mid: Opaque entity ID. Some IDs may be available in
                                                            	// [Google Knowledge Graph
                                                            	// Search
                                                            	// API](https://developers.google.com/knowledge-graph/).
                                                            	Mid string `json:"mid,omitempty"`
                                                            
                                                            	// Properties: Some entities may have optional user-supplied `Property`
                                                            	// (name/value)
                                                            	// fields, such a score or string that qualifies the entity.
                                                            	Properties []*Property `json:"properties,omitempty"`
                                                            
                                                            	// Score: Overall score of the result. Range [0, 1].
                                                            	Score float64 `json:"score,omitempty"`
                                                            
                                                            	// Topicality: The relevancy of the ICA (Image Content Annotation) label
                                                            	// to the
                                                            	// image. For example, the relevancy of "tower" is likely higher to an
                                                            	// image
                                                            	// containing the detected "Eiffel Tower" than to an image containing
                                                            	// a
                                                            	// detected distant towering building, even though the confidence
                                                            	// that
                                                            	// there is a tower in each image may be the same. Range [0, 1].
                                                            	Topicality float64 `json:"topicality,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "BoundingPoly") 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. "BoundingPoly") 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:"-"`
                                                            }

                                                              EntityAnnotation: Set of detected entity features.

                                                              func (*EntityAnnotation) MarshalJSON

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

                                                              func (*EntityAnnotation) UnmarshalJSON

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

                                                              type FaceAnnotation

                                                              type FaceAnnotation struct {
                                                              	// AngerLikelihood: Anger likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	AngerLikelihood string `json:"angerLikelihood,omitempty"`
                                                              
                                                              	// BlurredLikelihood: Blurred likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	BlurredLikelihood string `json:"blurredLikelihood,omitempty"`
                                                              
                                                              	// BoundingPoly: The bounding polygon around the face. The coordinates
                                                              	// of the bounding box
                                                              	// are in the original image's scale.
                                                              	// The bounding box is computed to "frame" the face in accordance with
                                                              	// human
                                                              	// expectations. It is based on the landmarker results.
                                                              	// Note that one or more x and/or y coordinates may not be generated in
                                                              	// the
                                                              	// `BoundingPoly` (the polygon will be unbounded) if only a partial
                                                              	// face
                                                              	// appears in the image to be annotated.
                                                              	BoundingPoly *BoundingPoly `json:"boundingPoly,omitempty"`
                                                              
                                                              	// DetectionConfidence: Detection confidence. Range [0, 1].
                                                              	DetectionConfidence float64 `json:"detectionConfidence,omitempty"`
                                                              
                                                              	// FdBoundingPoly: The `fd_bounding_poly` bounding polygon is tighter
                                                              	// than the
                                                              	// `boundingPoly`, and encloses only the skin part of the face.
                                                              	// Typically, it
                                                              	// is used to eliminate the face from any image analysis that detects
                                                              	// the
                                                              	// "amount of skin" visible in an image. It is not based on
                                                              	// the
                                                              	// landmarker results, only on the initial face detection, hence
                                                              	// the <code>fd</code> (face detection) prefix.
                                                              	FdBoundingPoly *BoundingPoly `json:"fdBoundingPoly,omitempty"`
                                                              
                                                              	// HeadwearLikelihood: Headwear likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	HeadwearLikelihood string `json:"headwearLikelihood,omitempty"`
                                                              
                                                              	// JoyLikelihood: Joy likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	JoyLikelihood string `json:"joyLikelihood,omitempty"`
                                                              
                                                              	// LandmarkingConfidence: Face landmarking confidence. Range [0, 1].
                                                              	LandmarkingConfidence float64 `json:"landmarkingConfidence,omitempty"`
                                                              
                                                              	// Landmarks: Detected face landmarks.
                                                              	Landmarks []*Landmark `json:"landmarks,omitempty"`
                                                              
                                                              	// PanAngle: Yaw angle, which indicates the leftward/rightward angle
                                                              	// that the face is
                                                              	// pointing relative to the vertical plane perpendicular to the image.
                                                              	// Range
                                                              	// [-180,180].
                                                              	PanAngle float64 `json:"panAngle,omitempty"`
                                                              
                                                              	// RollAngle: Roll angle, which indicates the amount of
                                                              	// clockwise/anti-clockwise rotation
                                                              	// of the face relative to the image vertical about the axis
                                                              	// perpendicular to
                                                              	// the face. Range [-180,180].
                                                              	RollAngle float64 `json:"rollAngle,omitempty"`
                                                              
                                                              	// SorrowLikelihood: Sorrow likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	SorrowLikelihood string `json:"sorrowLikelihood,omitempty"`
                                                              
                                                              	// SurpriseLikelihood: Surprise likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	SurpriseLikelihood string `json:"surpriseLikelihood,omitempty"`
                                                              
                                                              	// TiltAngle: Pitch angle, which indicates the upwards/downwards angle
                                                              	// that the face is
                                                              	// pointing relative to the image's horizontal plane. Range [-180,180].
                                                              	TiltAngle float64 `json:"tiltAngle,omitempty"`
                                                              
                                                              	// UnderExposedLikelihood: Under-exposed likelihood.
                                                              	//
                                                              	// Possible values:
                                                              	//   "UNKNOWN" - Unknown likelihood.
                                                              	//   "VERY_UNLIKELY" - It is very unlikely.
                                                              	//   "UNLIKELY" - It is unlikely.
                                                              	//   "POSSIBLE" - It is possible.
                                                              	//   "LIKELY" - It is likely.
                                                              	//   "VERY_LIKELY" - It is very likely.
                                                              	UnderExposedLikelihood string `json:"underExposedLikelihood,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "AngerLikelihood") 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. "AngerLikelihood") 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:"-"`
                                                              }

                                                                FaceAnnotation: A face annotation object contains the results of face detection.

                                                                func (*FaceAnnotation) MarshalJSON

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

                                                                func (*FaceAnnotation) UnmarshalJSON

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

                                                                type Feature

                                                                type Feature struct {
                                                                	// MaxResults: Maximum number of results of this type. Does not apply
                                                                	// to
                                                                	// `TEXT_DETECTION`, `DOCUMENT_TEXT_DETECTION`, or `CROP_HINTS`.
                                                                	MaxResults int64 `json:"maxResults,omitempty"`
                                                                
                                                                	// Model: Model to use for the feature.
                                                                	// Supported values: "builtin/stable" (the default if unset)
                                                                	// and
                                                                	// "builtin/latest".
                                                                	Model string `json:"model,omitempty"`
                                                                
                                                                	// Type: The feature type.
                                                                	//
                                                                	// Possible values:
                                                                	//   "TYPE_UNSPECIFIED" - Unspecified feature type.
                                                                	//   "FACE_DETECTION" - Run face detection.
                                                                	//   "LANDMARK_DETECTION" - Run landmark detection.
                                                                	//   "LOGO_DETECTION" - Run logo detection.
                                                                	//   "LABEL_DETECTION" - Run label detection.
                                                                	//   "TEXT_DETECTION" - Run text detection / optical character
                                                                	// recognition (OCR). Text detection
                                                                	// is optimized for areas of text within a larger image; if the image
                                                                	// is
                                                                	// a document, use `DOCUMENT_TEXT_DETECTION` instead.
                                                                	//   "DOCUMENT_TEXT_DETECTION" - Run dense text document OCR. Takes
                                                                	// precedence when both
                                                                	// `DOCUMENT_TEXT_DETECTION` and `TEXT_DETECTION` are present.
                                                                	//   "SAFE_SEARCH_DETECTION" - Run Safe Search to detect potentially
                                                                	// unsafe
                                                                	// or undesirable content.
                                                                	//   "IMAGE_PROPERTIES" - Compute a set of image properties, such as
                                                                	// the
                                                                	// image's dominant colors.
                                                                	//   "CROP_HINTS" - Run crop hints.
                                                                	//   "WEB_DETECTION" - Run web detection.
                                                                	//   "PRODUCT_SEARCH" - Run Product Search.
                                                                	//   "OBJECT_LOCALIZATION" - Run localizer for object detection.
                                                                	Type string `json:"type,omitempty"`
                                                                
                                                                	// ForceSendFields is a list of field names (e.g. "MaxResults") 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. "MaxResults") 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:"-"`
                                                                }

                                                                  Feature: The type of Google Cloud Vision API detection to perform, and the maximum number of results to return for that type. Multiple `Feature` objects can be specified in the `features` list.

                                                                  func (*Feature) MarshalJSON

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

                                                                  type FilesAnnotateCall

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

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

                                                                      Do executes the "vision.files.annotate" call. Exactly one of *BatchAnnotateFilesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *BatchAnnotateFilesResponse.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 (*FilesAnnotateCall) Fields

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

                                                                        func (*FilesAnnotateCall) Header

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

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

                                                                          type FilesAsyncBatchAnnotateCall

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

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

                                                                              Do executes the "vision.files.asyncBatchAnnotate" 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 (*FilesAsyncBatchAnnotateCall) Fields

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

                                                                                func (*FilesAsyncBatchAnnotateCall) Header

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

                                                                                  type FilesService

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

                                                                                  func NewFilesService

                                                                                  func NewFilesService(s *Service) *FilesService

                                                                                  func (*FilesService) Annotate

                                                                                  func (r *FilesService) Annotate(batchannotatefilesrequest *BatchAnnotateFilesRequest) *FilesAnnotateCall

                                                                                    Annotate: Service that performs image detection and annotation for a batch of files. Now only "application/pdf", "image/tiff" and "image/gif" are supported.

                                                                                    This service will extract at most 5 (customers can specify which 5 in AnnotateFileRequest.pages) frames (gif) or pages (pdf or tiff) from each file provided and perform detection and annotation for each image extracted.

                                                                                    func (*FilesService) AsyncBatchAnnotate

                                                                                    func (r *FilesService) AsyncBatchAnnotate(asyncbatchannotatefilesrequest *AsyncBatchAnnotateFilesRequest) *FilesAsyncBatchAnnotateCall

                                                                                      AsyncBatchAnnotate: Run asynchronous image detection and annotation for a list of generic files, such as PDF files, which may contain multiple pages and multiple images per page. Progress and results can be retrieved through the `google.longrunning.Operations` interface. `Operation.metadata` contains `OperationMetadata` (metadata). `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results).

                                                                                      type GcsDestination

                                                                                      type GcsDestination struct {
                                                                                      	// Uri: Google Cloud Storage URI prefix where the results will be
                                                                                      	// stored. Results
                                                                                      	// will be in JSON format and preceded by its corresponding input URI
                                                                                      	// prefix.
                                                                                      	// This field can either represent a gcs file prefix or gcs directory.
                                                                                      	// In
                                                                                      	// either case, the uri should be unique because in order to get all of
                                                                                      	// the
                                                                                      	// output files, you will need to do a wildcard gcs search on the uri
                                                                                      	// prefix
                                                                                      	// you provide.
                                                                                      	//
                                                                                      	// Examples:
                                                                                      	//
                                                                                      	// *    File Prefix: gs://bucket-name/here/filenameprefix   The output
                                                                                      	// files
                                                                                      	// will be created in gs://bucket-name/here/ and the names of the
                                                                                      	// output files will begin with "filenameprefix".
                                                                                      	//
                                                                                      	// *    Directory Prefix: gs://bucket-name/some/location/   The output
                                                                                      	// files
                                                                                      	// will be created in gs://bucket-name/some/location/ and the names of
                                                                                      	// the
                                                                                      	// output files could be anything because there was no filename
                                                                                      	// prefix
                                                                                      	// specified.
                                                                                      	//
                                                                                      	// If multiple outputs, each response is still AnnotateFileResponse,
                                                                                      	// each of
                                                                                      	// which contains some subset of the full list of
                                                                                      	// AnnotateImageResponse.
                                                                                      	// Multiple outputs can happen if, for example, the output JSON is too
                                                                                      	// large
                                                                                      	// and overflows into multiple sharded files.
                                                                                      	Uri string `json:"uri,omitempty"`
                                                                                      
                                                                                      	// ForceSendFields is a list of field names (e.g. "Uri") 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. "Uri") 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 where the output will be written to.

                                                                                        func (*GcsDestination) MarshalJSON

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

                                                                                        type GcsSource

                                                                                        type GcsSource struct {
                                                                                        	// Uri: Google Cloud Storage URI for the input file. This must only be
                                                                                        	// a
                                                                                        	// Google Cloud Storage object. Wildcards are not currently supported.
                                                                                        	Uri string `json:"uri,omitempty"`
                                                                                        
                                                                                        	// ForceSendFields is a list of field names (e.g. "Uri") 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. "Uri") 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 where the input will be read from.

                                                                                          func (*GcsSource) MarshalJSON

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

                                                                                          type GoogleCloudVisionV1p1beta1AnnotateFileResponse

                                                                                          type GoogleCloudVisionV1p1beta1AnnotateFileResponse struct {
                                                                                          	// Error: If set, represents the error message for the failed request.
                                                                                          	// The
                                                                                          	// `responses` field will not be set in this case.
                                                                                          	Error *Status `json:"error,omitempty"`
                                                                                          
                                                                                          	// InputConfig: Information about the file for which this response is
                                                                                          	// generated.
                                                                                          	InputConfig *GoogleCloudVisionV1p1beta1InputConfig `json:"inputConfig,omitempty"`
                                                                                          
                                                                                          	// Responses: Individual responses to images found within the file. This
                                                                                          	// field will be
                                                                                          	// empty if the `error` field is set.
                                                                                          	Responses []*GoogleCloudVisionV1p1beta1AnnotateImageResponse `json:"responses,omitempty"`
                                                                                          
                                                                                          	// TotalPages: This field gives the total number of pages in the file.
                                                                                          	TotalPages int64 `json:"totalPages,omitempty"`
                                                                                          
                                                                                          	// ForceSendFields is a list of field names (e.g. "Error") 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. "Error") 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:"-"`
                                                                                          }

                                                                                            GoogleCloudVisionV1p1beta1AnnotateFileResponse: Response to a single file annotation request. A file may contain one or more images, which individually have their own responses.

                                                                                            func (*GoogleCloudVisionV1p1beta1AnnotateFileResponse) MarshalJSON

                                                                                            type GoogleCloudVisionV1p1beta1AnnotateImageResponse

                                                                                            type GoogleCloudVisionV1p1beta1AnnotateImageResponse struct {
                                                                                            	// Context: If present, contextual information is needed to understand
                                                                                            	// where this image
                                                                                            	// comes from.
                                                                                            	Context *GoogleCloudVisionV1p1beta1ImageAnnotationContext `json:"context,omitempty"`
                                                                                            
                                                                                            	// CropHintsAnnotation: If present, crop hints have completed
                                                                                            	// successfully.
                                                                                            	CropHintsAnnotation *GoogleCloudVisionV1p1beta1CropHintsAnnotation `json:"cropHintsAnnotation,omitempty"`
                                                                                            
                                                                                            	// Error: If set, represents the error message for the operation.
                                                                                            	// Note that filled-in image annotations are guaranteed to be
                                                                                            	// correct, even when `error` is set.
                                                                                            	Error *Status `json:"error,omitempty"`
                                                                                            
                                                                                            	// FaceAnnotations: If present, face detection has completed
                                                                                            	// successfully.
                                                                                            	FaceAnnotations []*GoogleCloudVisionV1p1beta1FaceAnnotation `json:"faceAnnotations,omitempty"`
                                                                                            
                                                                                            	// FullTextAnnotation: If present, text (OCR) detection or document
                                                                                            	// (OCR) text detection has
                                                                                            	// completed successfully.
                                                                                            	// This annotation provides the structural hierarchy for the OCR
                                                                                            	// detected
                                                                                            	// text.
                                                                                            	FullTextAnnotation *GoogleCloudVisionV1p1beta1TextAnnotation `json:"fullTextAnnotation,omitempty"`
                                                                                            
                                                                                            	// ImagePropertiesAnnotation: If present, image properties were
                                                                                            	// extracted successfully.
                                                                                            	ImagePropertiesAnnotation *GoogleCloudVisionV1p1beta1ImageProperties `json:"imagePropertiesAnnotation,omitempty"`
                                                                                            
                                                                                            	// LabelAnnotations: If present, label detection has completed
                                                                                            	// successfully.
                                                                                            	LabelAnnotations []*GoogleCloudVisionV1p1beta1EntityAnnotation `json:"labelAnnotations,omitempty"`
                                                                                            
                                                                                            	// LandmarkAnnotations: If present, landmark detection has completed
                                                                                            	// successfully.
                                                                                            	LandmarkAnnotations []*GoogleCloudVisionV1p1beta1EntityAnnotation `json:"landmarkAnnotations,omitempty"`
                                                                                            
                                                                                            	// LocalizedObjectAnnotations: If present, localized object detection
                                                                                            	// has completed successfully.
                                                                                            	// This will be sorted descending by confidence score.
                                                                                            	LocalizedObjectAnnotations []*GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation `json:"localizedObjectAnnotations,omitempty"`
                                                                                            
                                                                                            	// LogoAnnotations: If present, logo detection has completed
                                                                                            	// successfully.
                                                                                            	LogoAnnotations []*GoogleCloudVisionV1p1beta1EntityAnnotation `json:"logoAnnotations,omitempty"`
                                                                                            
                                                                                            	// ProductSearchResults: If present, product search has completed
                                                                                            	// successfully.
                                                                                            	ProductSearchResults *GoogleCloudVisionV1p1beta1ProductSearchResults `json:"productSearchResults,omitempty"`
                                                                                            
                                                                                            	// SafeSearchAnnotation: If present, safe-search annotation has
                                                                                            	// completed successfully.
                                                                                            	SafeSearchAnnotation *GoogleCloudVisionV1p1beta1SafeSearchAnnotation `json:"safeSearchAnnotation,omitempty"`
                                                                                            
                                                                                            	// TextAnnotations: If present, text (OCR) detection has completed
                                                                                            	// successfully.
                                                                                            	TextAnnotations []*GoogleCloudVisionV1p1beta1EntityAnnotation `json:"textAnnotations,omitempty"`
                                                                                            
                                                                                            	// WebDetection: If present, web detection has completed successfully.
                                                                                            	WebDetection *GoogleCloudVisionV1p1beta1WebDetection `json:"webDetection,omitempty"`
                                                                                            
                                                                                            	// ForceSendFields is a list of field names (e.g. "Context") 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. "Context") 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:"-"`
                                                                                            }

                                                                                              GoogleCloudVisionV1p1beta1AnnotateImageResponse: Response to an image annotation request.

                                                                                              func (*GoogleCloudVisionV1p1beta1AnnotateImageResponse) MarshalJSON

                                                                                              type GoogleCloudVisionV1p1beta1AsyncAnnotateFileResponse

                                                                                              type GoogleCloudVisionV1p1beta1AsyncAnnotateFileResponse struct {
                                                                                              	// OutputConfig: The output location and metadata from
                                                                                              	// AsyncAnnotateFileRequest.
                                                                                              	OutputConfig *GoogleCloudVisionV1p1beta1OutputConfig `json:"outputConfig,omitempty"`
                                                                                              
                                                                                              	// ForceSendFields is a list of field names (e.g. "OutputConfig") 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. "OutputConfig") 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:"-"`
                                                                                              }

                                                                                                GoogleCloudVisionV1p1beta1AsyncAnnotateFileResponse: The response for a single offline file annotation request.

                                                                                                func (*GoogleCloudVisionV1p1beta1AsyncAnnotateFileResponse) MarshalJSON

                                                                                                type GoogleCloudVisionV1p1beta1AsyncBatchAnnotateFilesResponse

                                                                                                type GoogleCloudVisionV1p1beta1AsyncBatchAnnotateFilesResponse struct {
                                                                                                	// Responses: The list of file annotation responses, one for each
                                                                                                	// request in
                                                                                                	// AsyncBatchAnnotateFilesRequest.
                                                                                                	Responses []*GoogleCloudVisionV1p1beta1AsyncAnnotateFileResponse `json:"responses,omitempty"`
                                                                                                
                                                                                                	// ForceSendFields is a list of field names (e.g. "Responses") 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. "Responses") 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:"-"`
                                                                                                }

                                                                                                  GoogleCloudVisionV1p1beta1AsyncBatchAnnotateFilesResponse: Response to an async batch file annotation request.

                                                                                                  func (*GoogleCloudVisionV1p1beta1AsyncBatchAnnotateFilesResponse) MarshalJSON

                                                                                                  type GoogleCloudVisionV1p1beta1Block

                                                                                                  type GoogleCloudVisionV1p1beta1Block struct {
                                                                                                  	// BlockType: Detected block type (text, image etc) for this block.
                                                                                                  	//
                                                                                                  	// Possible values:
                                                                                                  	//   "UNKNOWN" - Unknown block type.
                                                                                                  	//   "TEXT" - Regular text block.
                                                                                                  	//   "TABLE" - Table block.
                                                                                                  	//   "PICTURE" - Image block.
                                                                                                  	//   "RULER" - Horizontal/vertical line box.
                                                                                                  	//   "BARCODE" - Barcode block.
                                                                                                  	BlockType string `json:"blockType,omitempty"`
                                                                                                  
                                                                                                  	// BoundingBox: The bounding box for the block.
                                                                                                  	// The vertices are in the order of top-left, top-right,
                                                                                                  	// bottom-right,
                                                                                                  	// bottom-left. When a rotation of the bounding box is detected the
                                                                                                  	// rotation
                                                                                                  	// is represented as around the top-left corner as defined when the text
                                                                                                  	// is
                                                                                                  	// read in the 'natural' orientation.
                                                                                                  	// For example:
                                                                                                  	//
                                                                                                  	// * when the text is horizontal it might look like:
                                                                                                  	//
                                                                                                  	//         0----1
                                                                                                  	//         |    |
                                                                                                  	//         3----2
                                                                                                  	//
                                                                                                  	// * when it's rotated 180 degrees around the top-left corner it
                                                                                                  	// becomes:
                                                                                                  	//
                                                                                                  	//         2----3
                                                                                                  	//         |    |
                                                                                                  	//         1----0
                                                                                                  	//
                                                                                                  	//   and the vertex order will still be (0, 1, 2, 3).
                                                                                                  	BoundingBox *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingBox,omitempty"`
                                                                                                  
                                                                                                  	// Confidence: Confidence of the OCR results on the block. Range [0, 1].
                                                                                                  	Confidence float64 `json:"confidence,omitempty"`
                                                                                                  
                                                                                                  	// Paragraphs: List of paragraphs in this block (if this blocks is of
                                                                                                  	// type text).
                                                                                                  	Paragraphs []*GoogleCloudVisionV1p1beta1Paragraph `json:"paragraphs,omitempty"`
                                                                                                  
                                                                                                  	// Property: Additional information detected for the block.
                                                                                                  	Property *GoogleCloudVisionV1p1beta1TextAnnotationTextProperty `json:"property,omitempty"`
                                                                                                  
                                                                                                  	// ForceSendFields is a list of field names (e.g. "BlockType") 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. "BlockType") 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:"-"`
                                                                                                  }

                                                                                                    GoogleCloudVisionV1p1beta1Block: Logical element on the page.

                                                                                                    func (*GoogleCloudVisionV1p1beta1Block) MarshalJSON

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

                                                                                                    func (*GoogleCloudVisionV1p1beta1Block) UnmarshalJSON

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

                                                                                                    type GoogleCloudVisionV1p1beta1BoundingPoly

                                                                                                    type GoogleCloudVisionV1p1beta1BoundingPoly struct {
                                                                                                    	// NormalizedVertices: The bounding polygon normalized vertices.
                                                                                                    	NormalizedVertices []*GoogleCloudVisionV1p1beta1NormalizedVertex `json:"normalizedVertices,omitempty"`
                                                                                                    
                                                                                                    	// Vertices: The bounding polygon vertices.
                                                                                                    	Vertices []*GoogleCloudVisionV1p1beta1Vertex `json:"vertices,omitempty"`
                                                                                                    
                                                                                                    	// ForceSendFields is a list of field names (e.g. "NormalizedVertices")
                                                                                                    	// 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. "NormalizedVertices") 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:"-"`
                                                                                                    }

                                                                                                      GoogleCloudVisionV1p1beta1BoundingPoly: A bounding polygon for the detected image annotation.

                                                                                                      func (*GoogleCloudVisionV1p1beta1BoundingPoly) MarshalJSON

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

                                                                                                      type GoogleCloudVisionV1p1beta1ColorInfo

                                                                                                      type GoogleCloudVisionV1p1beta1ColorInfo struct {
                                                                                                      	// Color: RGB components of the color.
                                                                                                      	Color *Color `json:"color,omitempty"`
                                                                                                      
                                                                                                      	// PixelFraction: The fraction of pixels the color occupies in the
                                                                                                      	// image.
                                                                                                      	// Value in range [0, 1].
                                                                                                      	PixelFraction float64 `json:"pixelFraction,omitempty"`
                                                                                                      
                                                                                                      	// Score: Image-specific score for this color. Value in range [0, 1].
                                                                                                      	Score float64 `json:"score,omitempty"`
                                                                                                      
                                                                                                      	// ForceSendFields is a list of field names (e.g. "Color") 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. "Color") 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:"-"`
                                                                                                      }

                                                                                                        GoogleCloudVisionV1p1beta1ColorInfo: Color information consists of RGB channels, score, and the fraction of the image that the color occupies in the image.

                                                                                                        func (*GoogleCloudVisionV1p1beta1ColorInfo) MarshalJSON

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

                                                                                                        func (*GoogleCloudVisionV1p1beta1ColorInfo) UnmarshalJSON

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

                                                                                                        type GoogleCloudVisionV1p1beta1CropHint

                                                                                                        type GoogleCloudVisionV1p1beta1CropHint struct {
                                                                                                        	// BoundingPoly: The bounding polygon for the crop region. The
                                                                                                        	// coordinates of the bounding
                                                                                                        	// box are in the original image's scale.
                                                                                                        	BoundingPoly *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingPoly,omitempty"`
                                                                                                        
                                                                                                        	// Confidence: Confidence of this being a salient region.  Range [0, 1].
                                                                                                        	Confidence float64 `json:"confidence,omitempty"`
                                                                                                        
                                                                                                        	// ImportanceFraction: Fraction of importance of this salient region
                                                                                                        	// with respect to the original
                                                                                                        	// image.
                                                                                                        	ImportanceFraction float64 `json:"importanceFraction,omitempty"`
                                                                                                        
                                                                                                        	// ForceSendFields is a list of field names (e.g. "BoundingPoly") 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. "BoundingPoly") 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:"-"`
                                                                                                        }

                                                                                                          GoogleCloudVisionV1p1beta1CropHint: Single crop hint that is used to generate a new crop when serving an image.

                                                                                                          func (*GoogleCloudVisionV1p1beta1CropHint) MarshalJSON

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

                                                                                                          func (*GoogleCloudVisionV1p1beta1CropHint) UnmarshalJSON

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

                                                                                                          type GoogleCloudVisionV1p1beta1CropHintsAnnotation

                                                                                                          type GoogleCloudVisionV1p1beta1CropHintsAnnotation struct {
                                                                                                          	// CropHints: Crop hint results.
                                                                                                          	CropHints []*GoogleCloudVisionV1p1beta1CropHint `json:"cropHints,omitempty"`
                                                                                                          
                                                                                                          	// ForceSendFields is a list of field names (e.g. "CropHints") 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. "CropHints") 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:"-"`
                                                                                                          }

                                                                                                            GoogleCloudVisionV1p1beta1CropHintsAnnotation: Set of crop hints that are used to generate new crops when serving images.

                                                                                                            func (*GoogleCloudVisionV1p1beta1CropHintsAnnotation) MarshalJSON

                                                                                                            type GoogleCloudVisionV1p1beta1DominantColorsAnnotation

                                                                                                            type GoogleCloudVisionV1p1beta1DominantColorsAnnotation struct {
                                                                                                            	// Colors: RGB color values with their score and pixel fraction.
                                                                                                            	Colors []*GoogleCloudVisionV1p1beta1ColorInfo `json:"colors,omitempty"`
                                                                                                            
                                                                                                            	// ForceSendFields is a list of field names (e.g. "Colors") 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. "Colors") 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:"-"`
                                                                                                            }

                                                                                                              GoogleCloudVisionV1p1beta1DominantColorsAnnotation: Set of dominant colors and their corresponding scores.

                                                                                                              func (*GoogleCloudVisionV1p1beta1DominantColorsAnnotation) MarshalJSON

                                                                                                              type GoogleCloudVisionV1p1beta1EntityAnnotation

                                                                                                              type GoogleCloudVisionV1p1beta1EntityAnnotation struct {
                                                                                                              	// BoundingPoly: Image region to which this entity belongs. Not
                                                                                                              	// produced
                                                                                                              	// for `LABEL_DETECTION` features.
                                                                                                              	BoundingPoly *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingPoly,omitempty"`
                                                                                                              
                                                                                                              	// Confidence: **Deprecated. Use `score` instead.**
                                                                                                              	// The accuracy of the entity detection in an image.
                                                                                                              	// For example, for an image in which the "Eiffel Tower" entity is
                                                                                                              	// detected,
                                                                                                              	// this field represents the confidence that there is a tower in the
                                                                                                              	// query
                                                                                                              	// image. Range [0, 1].
                                                                                                              	Confidence float64 `json:"confidence,omitempty"`
                                                                                                              
                                                                                                              	// Description: Entity textual description, expressed in its `locale`
                                                                                                              	// language.
                                                                                                              	Description string `json:"description,omitempty"`
                                                                                                              
                                                                                                              	// Locale: The language code for the locale in which the entity
                                                                                                              	// textual
                                                                                                              	// `description` is expressed.
                                                                                                              	Locale string `json:"locale,omitempty"`
                                                                                                              
                                                                                                              	// Locations: The location information for the detected entity.
                                                                                                              	// Multiple
                                                                                                              	// `LocationInfo` elements can be present because one location
                                                                                                              	// may
                                                                                                              	// indicate the location of the scene in the image, and another
                                                                                                              	// location
                                                                                                              	// may indicate the location of the place where the image was
                                                                                                              	// taken.
                                                                                                              	// Location information is usually present for landmarks.
                                                                                                              	Locations []*GoogleCloudVisionV1p1beta1LocationInfo `json:"locations,omitempty"`
                                                                                                              
                                                                                                              	// Mid: Opaque entity ID. Some IDs may be available in
                                                                                                              	// [Google Knowledge Graph
                                                                                                              	// Search
                                                                                                              	// API](https://developers.google.com/knowledge-graph/).
                                                                                                              	Mid string `json:"mid,omitempty"`
                                                                                                              
                                                                                                              	// Properties: Some entities may have optional user-supplied `Property`
                                                                                                              	// (name/value)
                                                                                                              	// fields, such a score or string that qualifies the entity.
                                                                                                              	Properties []*GoogleCloudVisionV1p1beta1Property `json:"properties,omitempty"`
                                                                                                              
                                                                                                              	// Score: Overall score of the result. Range [0, 1].
                                                                                                              	Score float64 `json:"score,omitempty"`
                                                                                                              
                                                                                                              	// Topicality: The relevancy of the ICA (Image Content Annotation) label
                                                                                                              	// to the
                                                                                                              	// image. For example, the relevancy of "tower" is likely higher to an
                                                                                                              	// image
                                                                                                              	// containing the detected "Eiffel Tower" than to an image containing
                                                                                                              	// a
                                                                                                              	// detected distant towering building, even though the confidence
                                                                                                              	// that
                                                                                                              	// there is a tower in each image may be the same. Range [0, 1].
                                                                                                              	Topicality float64 `json:"topicality,omitempty"`
                                                                                                              
                                                                                                              	// ForceSendFields is a list of field names (e.g. "BoundingPoly") 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. "BoundingPoly") 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:"-"`
                                                                                                              }

                                                                                                                GoogleCloudVisionV1p1beta1EntityAnnotation: Set of detected entity features.

                                                                                                                func (*GoogleCloudVisionV1p1beta1EntityAnnotation) MarshalJSON

                                                                                                                func (*GoogleCloudVisionV1p1beta1EntityAnnotation) UnmarshalJSON

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

                                                                                                                type GoogleCloudVisionV1p1beta1FaceAnnotation

                                                                                                                type GoogleCloudVisionV1p1beta1FaceAnnotation struct {
                                                                                                                	// AngerLikelihood: Anger likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	AngerLikelihood string `json:"angerLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// BlurredLikelihood: Blurred likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	BlurredLikelihood string `json:"blurredLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// BoundingPoly: The bounding polygon around the face. The coordinates
                                                                                                                	// of the bounding box
                                                                                                                	// are in the original image's scale.
                                                                                                                	// The bounding box is computed to "frame" the face in accordance with
                                                                                                                	// human
                                                                                                                	// expectations. It is based on the landmarker results.
                                                                                                                	// Note that one or more x and/or y coordinates may not be generated in
                                                                                                                	// the
                                                                                                                	// `BoundingPoly` (the polygon will be unbounded) if only a partial
                                                                                                                	// face
                                                                                                                	// appears in the image to be annotated.
                                                                                                                	BoundingPoly *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingPoly,omitempty"`
                                                                                                                
                                                                                                                	// DetectionConfidence: Detection confidence. Range [0, 1].
                                                                                                                	DetectionConfidence float64 `json:"detectionConfidence,omitempty"`
                                                                                                                
                                                                                                                	// FdBoundingPoly: The `fd_bounding_poly` bounding polygon is tighter
                                                                                                                	// than the
                                                                                                                	// `boundingPoly`, and encloses only the skin part of the face.
                                                                                                                	// Typically, it
                                                                                                                	// is used to eliminate the face from any image analysis that detects
                                                                                                                	// the
                                                                                                                	// "amount of skin" visible in an image. It is not based on
                                                                                                                	// the
                                                                                                                	// landmarker results, only on the initial face detection, hence
                                                                                                                	// the <code>fd</code> (face detection) prefix.
                                                                                                                	FdBoundingPoly *GoogleCloudVisionV1p1beta1BoundingPoly `json:"fdBoundingPoly,omitempty"`
                                                                                                                
                                                                                                                	// HeadwearLikelihood: Headwear likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	HeadwearLikelihood string `json:"headwearLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// JoyLikelihood: Joy likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	JoyLikelihood string `json:"joyLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// LandmarkingConfidence: Face landmarking confidence. Range [0, 1].
                                                                                                                	LandmarkingConfidence float64 `json:"landmarkingConfidence,omitempty"`
                                                                                                                
                                                                                                                	// Landmarks: Detected face landmarks.
                                                                                                                	Landmarks []*GoogleCloudVisionV1p1beta1FaceAnnotationLandmark `json:"landmarks,omitempty"`
                                                                                                                
                                                                                                                	// PanAngle: Yaw angle, which indicates the leftward/rightward angle
                                                                                                                	// that the face is
                                                                                                                	// pointing relative to the vertical plane perpendicular to the image.
                                                                                                                	// Range
                                                                                                                	// [-180,180].
                                                                                                                	PanAngle float64 `json:"panAngle,omitempty"`
                                                                                                                
                                                                                                                	// RollAngle: Roll angle, which indicates the amount of
                                                                                                                	// clockwise/anti-clockwise rotation
                                                                                                                	// of the face relative to the image vertical about the axis
                                                                                                                	// perpendicular to
                                                                                                                	// the face. Range [-180,180].
                                                                                                                	RollAngle float64 `json:"rollAngle,omitempty"`
                                                                                                                
                                                                                                                	// SorrowLikelihood: Sorrow likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	SorrowLikelihood string `json:"sorrowLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// SurpriseLikelihood: Surprise likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	SurpriseLikelihood string `json:"surpriseLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// TiltAngle: Pitch angle, which indicates the upwards/downwards angle
                                                                                                                	// that the face is
                                                                                                                	// pointing relative to the image's horizontal plane. Range [-180,180].
                                                                                                                	TiltAngle float64 `json:"tiltAngle,omitempty"`
                                                                                                                
                                                                                                                	// UnderExposedLikelihood: Under-exposed likelihood.
                                                                                                                	//
                                                                                                                	// Possible values:
                                                                                                                	//   "UNKNOWN" - Unknown likelihood.
                                                                                                                	//   "VERY_UNLIKELY" - It is very unlikely.
                                                                                                                	//   "UNLIKELY" - It is unlikely.
                                                                                                                	//   "POSSIBLE" - It is possible.
                                                                                                                	//   "LIKELY" - It is likely.
                                                                                                                	//   "VERY_LIKELY" - It is very likely.
                                                                                                                	UnderExposedLikelihood string `json:"underExposedLikelihood,omitempty"`
                                                                                                                
                                                                                                                	// ForceSendFields is a list of field names (e.g. "AngerLikelihood") 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. "AngerLikelihood") 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:"-"`
                                                                                                                }

                                                                                                                  GoogleCloudVisionV1p1beta1FaceAnnotation: A face annotation object contains the results of face detection.

                                                                                                                  func (*GoogleCloudVisionV1p1beta1FaceAnnotation) MarshalJSON

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

                                                                                                                  func (*GoogleCloudVisionV1p1beta1FaceAnnotation) UnmarshalJSON

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

                                                                                                                  type GoogleCloudVisionV1p1beta1FaceAnnotationLandmark

                                                                                                                  type GoogleCloudVisionV1p1beta1FaceAnnotationLandmark struct {
                                                                                                                  	// Position: Face landmark position.
                                                                                                                  	Position *GoogleCloudVisionV1p1beta1Position `json:"position,omitempty"`
                                                                                                                  
                                                                                                                  	// Type: Face landmark type.
                                                                                                                  	//
                                                                                                                  	// Possible values:
                                                                                                                  	//   "UNKNOWN_LANDMARK" - Unknown face landmark detected. Should not be
                                                                                                                  	// filled.
                                                                                                                  	//   "LEFT_EYE" - Left eye.
                                                                                                                  	//   "RIGHT_EYE" - Right eye.
                                                                                                                  	//   "LEFT_OF_LEFT_EYEBROW" - Left of left eyebrow.
                                                                                                                  	//   "RIGHT_OF_LEFT_EYEBROW" - Right of left eyebrow.
                                                                                                                  	//   "LEFT_OF_RIGHT_EYEBROW" - Left of right eyebrow.
                                                                                                                  	//   "RIGHT_OF_RIGHT_EYEBROW" - Right of right eyebrow.
                                                                                                                  	//   "MIDPOINT_BETWEEN_EYES" - Midpoint between eyes.
                                                                                                                  	//   "NOSE_TIP" - Nose tip.
                                                                                                                  	//   "UPPER_LIP" - Upper lip.
                                                                                                                  	//   "LOWER_LIP" - Lower lip.
                                                                                                                  	//   "MOUTH_LEFT" - Mouth left.
                                                                                                                  	//   "MOUTH_RIGHT" - Mouth right.
                                                                                                                  	//   "MOUTH_CENTER" - Mouth center.
                                                                                                                  	//   "NOSE_BOTTOM_RIGHT" - Nose, bottom right.
                                                                                                                  	//   "NOSE_BOTTOM_LEFT" - Nose, bottom left.
                                                                                                                  	//   "NOSE_BOTTOM_CENTER" - Nose, bottom center.
                                                                                                                  	//   "LEFT_EYE_TOP_BOUNDARY" - Left eye, top boundary.
                                                                                                                  	//   "LEFT_EYE_RIGHT_CORNER" - Left eye, right corner.
                                                                                                                  	//   "LEFT_EYE_BOTTOM_BOUNDARY" - Left eye, bottom boundary.
                                                                                                                  	//   "LEFT_EYE_LEFT_CORNER" - Left eye, left corner.
                                                                                                                  	//   "RIGHT_EYE_TOP_BOUNDARY" - Right eye, top boundary.
                                                                                                                  	//   "RIGHT_EYE_RIGHT_CORNER" - Right eye, right corner.
                                                                                                                  	//   "RIGHT_EYE_BOTTOM_BOUNDARY" - Right eye, bottom boundary.
                                                                                                                  	//   "RIGHT_EYE_LEFT_CORNER" - Right eye, left corner.
                                                                                                                  	//   "LEFT_EYEBROW_UPPER_MIDPOINT" - Left eyebrow, upper midpoint.
                                                                                                                  	//   "RIGHT_EYEBROW_UPPER_MIDPOINT" - Right eyebrow, upper midpoint.
                                                                                                                  	//   "LEFT_EAR_TRAGION" - Left ear tragion.
                                                                                                                  	//   "RIGHT_EAR_TRAGION" - Right ear tragion.
                                                                                                                  	//   "LEFT_EYE_PUPIL" - Left eye pupil.
                                                                                                                  	//   "RIGHT_EYE_PUPIL" - Right eye pupil.
                                                                                                                  	//   "FOREHEAD_GLABELLA" - Forehead glabella.
                                                                                                                  	//   "CHIN_GNATHION" - Chin gnathion.
                                                                                                                  	//   "CHIN_LEFT_GONION" - Chin left gonion.
                                                                                                                  	//   "CHIN_RIGHT_GONION" - Chin right gonion.
                                                                                                                  	Type string `json:"type,omitempty"`
                                                                                                                  
                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Position") 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. "Position") 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:"-"`
                                                                                                                  }

                                                                                                                    GoogleCloudVisionV1p1beta1FaceAnnotationLandmark: A face-specific landmark (for example, a face feature).

                                                                                                                    func (*GoogleCloudVisionV1p1beta1FaceAnnotationLandmark) MarshalJSON

                                                                                                                    type GoogleCloudVisionV1p1beta1GcsDestination

                                                                                                                    type GoogleCloudVisionV1p1beta1GcsDestination struct {
                                                                                                                    	// Uri: Google Cloud Storage URI prefix where the results will be
                                                                                                                    	// stored. Results
                                                                                                                    	// will be in JSON format and preceded by its corresponding input URI
                                                                                                                    	// prefix.
                                                                                                                    	// This field can either represent a gcs file prefix or gcs directory.
                                                                                                                    	// In
                                                                                                                    	// either case, the uri should be unique because in order to get all of
                                                                                                                    	// the
                                                                                                                    	// output files, you will need to do a wildcard gcs search on the uri
                                                                                                                    	// prefix
                                                                                                                    	// you provide.
                                                                                                                    	//
                                                                                                                    	// Examples:
                                                                                                                    	//
                                                                                                                    	// *    File Prefix: gs://bucket-name/here/filenameprefix   The output
                                                                                                                    	// files
                                                                                                                    	// will be created in gs://bucket-name/here/ and the names of the
                                                                                                                    	// output files will begin with "filenameprefix".
                                                                                                                    	//
                                                                                                                    	// *    Directory Prefix: gs://bucket-name/some/location/   The output
                                                                                                                    	// files
                                                                                                                    	// will be created in gs://bucket-name/some/location/ and the names of
                                                                                                                    	// the
                                                                                                                    	// output files could be anything because there was no filename
                                                                                                                    	// prefix
                                                                                                                    	// specified.
                                                                                                                    	//
                                                                                                                    	// If multiple outputs, each response is still AnnotateFileResponse,
                                                                                                                    	// each of
                                                                                                                    	// which contains some subset of the full list of
                                                                                                                    	// AnnotateImageResponse.
                                                                                                                    	// Multiple outputs can happen if, for example, the output JSON is too
                                                                                                                    	// large
                                                                                                                    	// and overflows into multiple sharded files.
                                                                                                                    	Uri string `json:"uri,omitempty"`
                                                                                                                    
                                                                                                                    	// ForceSendFields is a list of field names (e.g. "Uri") 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. "Uri") 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:"-"`
                                                                                                                    }

                                                                                                                      GoogleCloudVisionV1p1beta1GcsDestination: The Google Cloud Storage location where the output will be written to.

                                                                                                                      func (*GoogleCloudVisionV1p1beta1GcsDestination) MarshalJSON

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

                                                                                                                      type GoogleCloudVisionV1p1beta1GcsSource

                                                                                                                      type GoogleCloudVisionV1p1beta1GcsSource struct {
                                                                                                                      	// Uri: Google Cloud Storage URI for the input file. This must only be
                                                                                                                      	// a
                                                                                                                      	// Google Cloud Storage object. Wildcards are not currently supported.
                                                                                                                      	Uri string `json:"uri,omitempty"`
                                                                                                                      
                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Uri") 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. "Uri") 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:"-"`
                                                                                                                      }

                                                                                                                        GoogleCloudVisionV1p1beta1GcsSource: The Google Cloud Storage location where the input will be read from.

                                                                                                                        func (*GoogleCloudVisionV1p1beta1GcsSource) MarshalJSON

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

                                                                                                                        type GoogleCloudVisionV1p1beta1ImageAnnotationContext

                                                                                                                        type GoogleCloudVisionV1p1beta1ImageAnnotationContext struct {
                                                                                                                        	// PageNumber: If the file was a PDF or TIFF, this field gives the page
                                                                                                                        	// number within
                                                                                                                        	// the file used to produce the image.
                                                                                                                        	PageNumber int64 `json:"pageNumber,omitempty"`
                                                                                                                        
                                                                                                                        	// Uri: The URI of the file used to produce the image.
                                                                                                                        	Uri string `json:"uri,omitempty"`
                                                                                                                        
                                                                                                                        	// ForceSendFields is a list of field names (e.g. "PageNumber") 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. "PageNumber") 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:"-"`
                                                                                                                        }

                                                                                                                          GoogleCloudVisionV1p1beta1ImageAnnotationContext: If an image was produced from a file (e.g. a PDF), this message gives information about the source of that image.

                                                                                                                          func (*GoogleCloudVisionV1p1beta1ImageAnnotationContext) MarshalJSON

                                                                                                                          type GoogleCloudVisionV1p1beta1ImageProperties

                                                                                                                          type GoogleCloudVisionV1p1beta1ImageProperties struct {
                                                                                                                          	// DominantColors: If present, dominant colors completed successfully.
                                                                                                                          	DominantColors *GoogleCloudVisionV1p1beta1DominantColorsAnnotation `json:"dominantColors,omitempty"`
                                                                                                                          
                                                                                                                          	// ForceSendFields is a list of field names (e.g. "DominantColors") 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. "DominantColors") 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:"-"`
                                                                                                                          }

                                                                                                                            GoogleCloudVisionV1p1beta1ImageProperties: Stores image properties, such as dominant colors.

                                                                                                                            func (*GoogleCloudVisionV1p1beta1ImageProperties) MarshalJSON

                                                                                                                            type GoogleCloudVisionV1p1beta1InputConfig

                                                                                                                            type GoogleCloudVisionV1p1beta1InputConfig struct {
                                                                                                                            	// Content: File content, represented as a stream of bytes.
                                                                                                                            	// Note: As with all `bytes` fields, protobuffers use a pure
                                                                                                                            	// binary
                                                                                                                            	// representation, whereas JSON representations use base64.
                                                                                                                            	//
                                                                                                                            	// Currently, this field only works for BatchAnnotateFiles requests. It
                                                                                                                            	// does
                                                                                                                            	// not work for AsyncBatchAnnotateFiles requests.
                                                                                                                            	Content string `json:"content,omitempty"`
                                                                                                                            
                                                                                                                            	// GcsSource: The Google Cloud Storage location to read the input from.
                                                                                                                            	GcsSource *GoogleCloudVisionV1p1beta1GcsSource `json:"gcsSource,omitempty"`
                                                                                                                            
                                                                                                                            	// MimeType: The type of the file. Currently only "application/pdf",
                                                                                                                            	// "image/tiff" and
                                                                                                                            	// "image/gif" are supported. Wildcards are not supported.
                                                                                                                            	MimeType string `json:"mimeType,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:"-"`
                                                                                                                            }

                                                                                                                              GoogleCloudVisionV1p1beta1InputConfig: The desired input location and metadata.

                                                                                                                              func (*GoogleCloudVisionV1p1beta1InputConfig) MarshalJSON

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

                                                                                                                              type GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation

                                                                                                                              type GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation struct {
                                                                                                                              	// BoundingPoly: Image region to which this object belongs. This must be
                                                                                                                              	// populated.
                                                                                                                              	BoundingPoly *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingPoly,omitempty"`
                                                                                                                              
                                                                                                                              	// LanguageCode: The BCP-47 language code, such as "en-US" or "sr-Latn".
                                                                                                                              	// For more
                                                                                                                              	// information,
                                                                                                                              	// see
                                                                                                                              	// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
                                                                                                                              	LanguageCode string `json:"languageCode,omitempty"`
                                                                                                                              
                                                                                                                              	// Mid: Object ID that should align with EntityAnnotation mid.
                                                                                                                              	Mid string `json:"mid,omitempty"`
                                                                                                                              
                                                                                                                              	// Name: Object name, expressed in its `language_code` language.
                                                                                                                              	Name string `json:"name,omitempty"`
                                                                                                                              
                                                                                                                              	// Score: Score of the result. Range [0, 1].
                                                                                                                              	Score float64 `json:"score,omitempty"`
                                                                                                                              
                                                                                                                              	// ForceSendFields is a list of field names (e.g. "BoundingPoly") 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. "BoundingPoly") 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:"-"`
                                                                                                                              }

                                                                                                                                GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation: Set of detected objects with bounding boxes.

                                                                                                                                func (*GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation) MarshalJSON

                                                                                                                                func (*GoogleCloudVisionV1p1beta1LocalizedObjectAnnotation) UnmarshalJSON

                                                                                                                                type GoogleCloudVisionV1p1beta1LocationInfo

                                                                                                                                type GoogleCloudVisionV1p1beta1LocationInfo struct {
                                                                                                                                	// LatLng: lat/long location coordinates.
                                                                                                                                	LatLng *LatLng `json:"latLng,omitempty"`
                                                                                                                                
                                                                                                                                	// ForceSendFields is a list of field names (e.g. "LatLng") 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. "LatLng") 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:"-"`
                                                                                                                                }

                                                                                                                                  GoogleCloudVisionV1p1beta1LocationInfo: Detected entity location information.

                                                                                                                                  func (*GoogleCloudVisionV1p1beta1LocationInfo) MarshalJSON

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

                                                                                                                                  type GoogleCloudVisionV1p1beta1NormalizedVertex

                                                                                                                                  type GoogleCloudVisionV1p1beta1NormalizedVertex struct {
                                                                                                                                  	// X: X coordinate.
                                                                                                                                  	X float64 `json:"x,omitempty"`
                                                                                                                                  
                                                                                                                                  	// Y: Y coordinate.
                                                                                                                                  	Y float64 `json:"y,omitempty"`
                                                                                                                                  
                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "X") 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. "X") 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:"-"`
                                                                                                                                  }

                                                                                                                                    GoogleCloudVisionV1p1beta1NormalizedVertex: A vertex represents a 2D point in the image. NOTE: the normalized vertex coordinates are relative to the original image and range from 0 to 1.

                                                                                                                                    func (*GoogleCloudVisionV1p1beta1NormalizedVertex) MarshalJSON

                                                                                                                                    func (*GoogleCloudVisionV1p1beta1NormalizedVertex) UnmarshalJSON

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

                                                                                                                                    type GoogleCloudVisionV1p1beta1OperationMetadata

                                                                                                                                    type GoogleCloudVisionV1p1beta1OperationMetadata struct {
                                                                                                                                    	// CreateTime: The time when the batch request was received.
                                                                                                                                    	CreateTime string `json:"createTime,omitempty"`
                                                                                                                                    
                                                                                                                                    	// State: Current state of the batch operation.
                                                                                                                                    	//
                                                                                                                                    	// Possible values:
                                                                                                                                    	//   "STATE_UNSPECIFIED" - Invalid.
                                                                                                                                    	//   "CREATED" - Request is received.
                                                                                                                                    	//   "RUNNING" - Request is actively being processed.
                                                                                                                                    	//   "DONE" - The batch processing is done.
                                                                                                                                    	//   "CANCELLED" - The batch processing was cancelled.
                                                                                                                                    	State string `json:"state,omitempty"`
                                                                                                                                    
                                                                                                                                    	// UpdateTime: The time when the operation result was last updated.
                                                                                                                                    	UpdateTime string `json:"updateTime,omitempty"`
                                                                                                                                    
                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "CreateTime") 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. "CreateTime") 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:"-"`
                                                                                                                                    }

                                                                                                                                      GoogleCloudVisionV1p1beta1OperationMetadata: Contains metadata for the BatchAnnotateImages operation.

                                                                                                                                      func (*GoogleCloudVisionV1p1beta1OperationMetadata) MarshalJSON

                                                                                                                                      type GoogleCloudVisionV1p1beta1OutputConfig

                                                                                                                                      type GoogleCloudVisionV1p1beta1OutputConfig struct {
                                                                                                                                      	// BatchSize: The max number of response protos to put into each output
                                                                                                                                      	// JSON file on
                                                                                                                                      	// Google Cloud Storage.
                                                                                                                                      	// The valid range is [1, 100]. If not specified, the default value is
                                                                                                                                      	// 20.
                                                                                                                                      	//
                                                                                                                                      	// For example, for one pdf file with 100 pages, 100 response protos
                                                                                                                                      	// will
                                                                                                                                      	// be generated. If `batch_size` = 20, then 5 json files each
                                                                                                                                      	// containing 20 response protos will be written under the
                                                                                                                                      	// prefix
                                                                                                                                      	// `gcs_destination`.`uri`.
                                                                                                                                      	//
                                                                                                                                      	// Currently, batch_size only applies to GcsDestination, with potential
                                                                                                                                      	// future
                                                                                                                                      	// support for other output configurations.
                                                                                                                                      	BatchSize int64 `json:"batchSize,omitempty"`
                                                                                                                                      
                                                                                                                                      	// GcsDestination: The Google Cloud Storage location to write the
                                                                                                                                      	// output(s) to.
                                                                                                                                      	GcsDestination *GoogleCloudVisionV1p1beta1GcsDestination `json:"gcsDestination,omitempty"`
                                                                                                                                      
                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "BatchSize") 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. "BatchSize") 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:"-"`
                                                                                                                                      }

                                                                                                                                        GoogleCloudVisionV1p1beta1OutputConfig: The desired output location and metadata.

                                                                                                                                        func (*GoogleCloudVisionV1p1beta1OutputConfig) MarshalJSON

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

                                                                                                                                        type GoogleCloudVisionV1p1beta1Page

                                                                                                                                        type GoogleCloudVisionV1p1beta1Page struct {
                                                                                                                                        	// Blocks: List of blocks of text, images etc on this page.
                                                                                                                                        	Blocks []*GoogleCloudVisionV1p1beta1Block `json:"blocks,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Confidence: Confidence of the OCR results on the page. Range [0, 1].
                                                                                                                                        	Confidence float64 `json:"confidence,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Height: Page height. For PDFs the unit is points. For images
                                                                                                                                        	// (including
                                                                                                                                        	// TIFFs) the unit is pixels.
                                                                                                                                        	Height int64 `json:"height,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Property: Additional information detected on the page.
                                                                                                                                        	Property *GoogleCloudVisionV1p1beta1TextAnnotationTextProperty `json:"property,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Width: Page width. For PDFs the unit is points. For images
                                                                                                                                        	// (including
                                                                                                                                        	// TIFFs) the unit is pixels.
                                                                                                                                        	Width int64 `json:"width,omitempty"`
                                                                                                                                        
                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Blocks") 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. "Blocks") 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:"-"`
                                                                                                                                        }

                                                                                                                                          GoogleCloudVisionV1p1beta1Page: Detected page from OCR.

                                                                                                                                          func (*GoogleCloudVisionV1p1beta1Page) MarshalJSON

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

                                                                                                                                          func (*GoogleCloudVisionV1p1beta1Page) UnmarshalJSON

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

                                                                                                                                          type GoogleCloudVisionV1p1beta1Paragraph

                                                                                                                                          type GoogleCloudVisionV1p1beta1Paragraph struct {
                                                                                                                                          	// BoundingBox: The bounding box for the paragraph.
                                                                                                                                          	// The vertices are in the order of top-left, top-right,
                                                                                                                                          	// bottom-right,
                                                                                                                                          	// bottom-left. When a rotation of the bounding box is detected the
                                                                                                                                          	// rotation
                                                                                                                                          	// is represented as around the top-left corner as defined when the text
                                                                                                                                          	// is
                                                                                                                                          	// read in the 'natural' orientation.
                                                                                                                                          	// For example:
                                                                                                                                          	//   * when the text is horizontal it might look like:
                                                                                                                                          	//      0----1
                                                                                                                                          	//      |    |
                                                                                                                                          	//      3----2
                                                                                                                                          	//   * when it's rotated 180 degrees around the top-left corner it
                                                                                                                                          	// becomes:
                                                                                                                                          	//      2----3
                                                                                                                                          	//      |    |
                                                                                                                                          	//      1----0
                                                                                                                                          	//   and the vertex order will still be (0, 1, 2, 3).
                                                                                                                                          	BoundingBox *GoogleCloudVisionV1p1beta1BoundingPoly `json:"boundingBox,omitempty"`
                                                                                                                                          
                                                                                                                                          	// Confidence: Confidence of the OCR results for the paragraph. Range
                                                                                                                                          	// [0, 1].
                                                                                                                                          	Confidence float64 `json:"confidence,omitempty"`
                                                                                                                                          
                                                                                                                                          	// Property: Additional information detected for the paragraph.
                                                                                                                                          	Property *GoogleCloudVisionV1p1beta1TextAnnotationTextProperty `json:"property,omitempty"`
                                                                                                                                          
                                                                                                                                          	// Words: List of all words in this paragraph.
                                                                                                                                          	Words []*GoogleCloudVisionV1p1beta1Word `json:"words,omitempty"`
                                                                                                                                          
                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "BoundingBox") 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. "BoundingBox") 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:"-"`
                                                                                                                                          }

                                                                                                                                            GoogleCloudVisionV1p1beta1Paragraph: Structural unit of text representing a number of words in certain order.

                                                                                                                                            func (*GoogleCloudVisionV1p1beta1Paragraph) MarshalJSON

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

                                                                                                                                            func (*GoogleCloudVisionV1p1beta1Paragraph) UnmarshalJSON

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

                                                                                                                                            type GoogleCloudVisionV1p1beta1Position

                                                                                                                                            type GoogleCloudVisionV1p1beta1Position struct {
                                                                                                                                            	// X: X coordinate.
                                                                                                                                            	X float64 `json:"x,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Y: Y coordinate.
                                                                                                                                            	Y float64 `json:"y,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Z: Z coordinate (or depth).
                                                                                                                                            	Z float64 `json:"z,omitempty"`
                                                                                                                                            
                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "X") 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. "X") 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:"-"`
                                                                                                                                            }

                                                                                                                                              GoogleCloudVisionV1p1beta1Position: A 3D position in the image, used primarily for Face detection landmarks. A valid Position must have both x and y coordinates. The position coordinates are in the same scale as the original image.

                                                                                                                                              func (*GoogleCloudVisionV1p1beta1Position) MarshalJSON

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

                                                                                                                                              func (*GoogleCloudVisionV1p1beta1Position) UnmarshalJSON

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

                                                                                                                                              type GoogleCloudVisionV1p1beta1Product

                                                                                                                                              type GoogleCloudVisionV1p1beta1Product struct {
                                                                                                                                              	// Description: User-provided metadata to be stored with this product.
                                                                                                                                              	// Must be at most 4096
                                                                                                                                              	// characters long.
                                                                                                                                              	Description string `json:"description,omitempty"`
                                                                                                                                              
                                                                                                                                              	// DisplayName: The user-provided name for this Product. Must not be
                                                                                                                                              	// empty. Must be at most
                                                                                                                                              	// 4096 characters long.
                                                                                                                                              	DisplayName string `json:"displayName,omitempty"`
                                                                                                                                              
                                                                                                                                              	// Name: The resource name of the product.
                                                                                                                                              	//
                                                                                                                                              	// Format
                                                                                                                                              	// is:
                                                                                                                                              	// `projects/PROJECT_ID/locations/LOC_ID/products/PRODUCT_ID`.
                                                                                                                                              	//
                                                                                                                                              	// This field is ignored when creating a product.
                                                                                                                                              	Name string `json:"name,omitempty"`
                                                                                                                                              
                                                                                                                                              	// ProductCategory: Immutable. The category for the product identified
                                                                                                                                              	// by the reference image. This should
                                                                                                                                              	// be either "homegoods-v2", "apparel-v2", or "toys-v2". The legacy
                                                                                                                                              	// categories
                                                                                                                                              	// "homegoods", "apparel", and "toys" are still supported, but these
                                                                                                                                              	// should
                                                                                                                                              	// not be used for new products.
                                                                                                                                              	ProductCategory string `json:"productCategory,omitempty"`
                                                                                                                                              
                                                                                                                                              	// ProductLabels: Key-value pairs that can be attached to a product. At
                                                                                                                                              	// query time,
                                                                                                                                              	// constraints can be specified based on the product_labels.
                                                                                                                                              	//
                                                                                                                                              	// Note that integer values can be provided as strings, e.g. "1199".
                                                                                                                                              	// Only
                                                                                                                                              	// strings with integer values can match a range-based restriction which
                                                                                                                                              	// is
                                                                                                                                              	// to be supported soon.
                                                                                                                                              	//
                                                                                                                                              	// Multiple values can be assigned to the same key. One product may have
                                                                                                                                              	// up to
                                                                                                                                              	// 500 product_labels.
                                                                                                                                              	//
                                                                                                                                              	// Notice that the total number of distinct product_labels over all
                                                                                                                                              	// products
                                                                                                                                              	// in one ProductSet cannot exceed 1M, otherwise the product search
                                                                                                                                              	// pipeline
                                                                                                                                              	// will refuse to work for that ProductSet.
                                                                                                                                              	ProductLabels []*GoogleCloudVisionV1p1beta1ProductKeyValue `json:"productLabels,omitempty"`
                                                                                                                                              
                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Description") 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. "Description") 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:"-"`
                                                                                                                                              }

                                                                                                                                                GoogleCloudVisionV1p1beta1Product: A Product contains ReferenceImages.

                                                                                                                                                func (*GoogleCloudVisionV1p1beta1Product) MarshalJSON

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

                                                                                                                                                type GoogleCloudVisionV1p1beta1ProductKeyValue

                                                                                                                                                type GoogleCloudVisionV1p1beta1ProductKeyValue struct {
                                                                                                                                                	// Key: The key of the label attached to the product. Cannot be empty
                                                                                                                                                	// and cannot
                                                                                                                                                	// exceed 128 bytes.
                                                                                                                                                	Key string `json:"key,omitempty"`
                                                                                                                                                
                                                                                                                                                	// Value: The value of the label attached to the product. Cannot be
                                                                                                                                                	// empty and
                                                                                                                                                	// cannot exceed 128 bytes.
                                                                                                                                                	Value string `json:"value,omitempty"`
                                                                                                                                                
                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Key") 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. "Key") 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:"-"`
                                                                                                                                                }

                                                                                                                                                  GoogleCloudVisionV1p1beta1ProductKeyValue: A product label represented as a key-value pair.

                                                                                                                                                  func (*GoogleCloudVisionV1p1beta1ProductKeyValue) MarshalJSON

                                                                                                                                                  type GoogleCloudVisionV1p1beta1ProductSearchResults

                                                                                                                                                  type GoogleCloudVisionV1p1beta1ProductSearchResults struct {
                                                                                                                                                  	// IndexTime: Timestamp of the index which provided these results.
                                                                                                                                                  	// Products added to the
                                                                                                                                                  	// product set and products removed from the product set after this time
                                                                                                                                                  	// are
                                                                                                                                                  	// not reflected in the current results.
                                                                                                                                                  	IndexTime string `json:"indexTime,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// ProductGroupedResults: List of results grouped by products detected
                                                                                                                                                  	// in the query image. Each entry
                                                                                                                                                  	// corresponds to one bounding polygon in the query image, and contains
                                                                                                                                                  	// the
                                                                                                                                                  	// matching products specific to that region. There may be duplicate
                                                                                                                                                  	// product
                                                                                                                                                  	// matches in the union of all the per-product results.
                                                                                                                                                  	ProductGroupedResults []*GoogleCloudVisionV1p1beta1ProductSearchResultsGroupedResult `json:"productGroupedResults,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// Results: List of results, one for each product match.
                                                                                                                                                  	Results []*GoogleCloudVisionV1p1beta1ProductSearchResultsResult `json:"results,omitempty"`