Documentation

Overview

Package cloudsearch provides access to the Cloud Search API.

For product documentation, see: https://developers.google.com/cloud-search/docs/guides/

Creating a client

Usage example:

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

cloudsearchService, err := cloudsearch.NewService(ctx, option.WithScopes(cloudsearch.CloudSearchStatsIndexingScope))

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

cloudsearchService, err := cloudsearch.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, ...)
cloudsearchService, err := cloudsearch.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 (
	// Index and serve your organization's data with Cloud Search
	CloudSearchScope = "https://www.googleapis.com/auth/cloud_search"

	// Index and serve your organization's data with Cloud Search
	CloudSearchDebugScope = "https://www.googleapis.com/auth/cloud_search.debug"

	// Index and serve your organization's data with Cloud Search
	CloudSearchIndexingScope = "https://www.googleapis.com/auth/cloud_search.indexing"

	// Search your organization's data in the Cloud Search index
	CloudSearchQueryScope = "https://www.googleapis.com/auth/cloud_search.query"

	// Index and serve your organization's data with Cloud Search
	CloudSearchSettingsScope = "https://www.googleapis.com/auth/cloud_search.settings"

	// Index and serve your organization's data with Cloud Search
	CloudSearchSettingsIndexingScope = "https://www.googleapis.com/auth/cloud_search.settings.indexing"

	// Index and serve your organization's data with Cloud Search
	CloudSearchSettingsQueryScope = "https://www.googleapis.com/auth/cloud_search.settings.query"

	// Index and serve your organization's data with Cloud Search
	CloudSearchStatsScope = "https://www.googleapis.com/auth/cloud_search.stats"

	// Index and serve your organization's data with Cloud Search
	CloudSearchStatsIndexingScope = "https://www.googleapis.com/auth/cloud_search.stats.indexing"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type BooleanOperatorOptions

    type BooleanOperatorOptions struct {
    	// OperatorName: Indicates the operator name required in the query in
    	// order to isolate the
    	// boolean property. For example, if operatorName is *closed* and
    	// the
    	// property's name is *isClosed*, then queries
    	// like
    	// *closed:<value>* show results only where the value of
    	// the
    	// property named *isClosed* matches *<value>*. By contrast,
    	// a
    	// search that uses the same *<value>* without an operator
    	// returns
    	// all items where *<value>* matches the value of any
    	// String properties or text within the content field for the item.
    	// The operator name can only contain lowercase letters (a-z).
    	// The maximum length is 32 characters.
    	OperatorName string `json:"operatorName,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "OperatorName") 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. "OperatorName") 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:"-"`
    }

      BooleanOperatorOptions: Used to provide a search operator for boolean properties. This is optional. Search operators let users restrict the query to specific fields relevant to the type of item being searched.

      func (*BooleanOperatorOptions) MarshalJSON

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

      type BooleanPropertyOptions

      type BooleanPropertyOptions struct {
      	// OperatorOptions: If set, describes how the boolean should be used as
      	// a search operator.
      	OperatorOptions *BooleanOperatorOptions `json:"operatorOptions,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g. "OperatorOptions") 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. "OperatorOptions") 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:"-"`
      }

        BooleanPropertyOptions: Options for boolean properties.

        func (*BooleanPropertyOptions) MarshalJSON

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

        type CheckAccessResponse

        type CheckAccessResponse struct {
        	// HasAccess: Returns true if principal has access.  Returns false
        	// otherwise.
        	HasAccess bool `json:"hasAccess,omitempty"`
        
        	// ServerResponse contains the HTTP response code and headers from the
        	// server.
        	googleapi.ServerResponse `json:"-"`
        
        	// ForceSendFields is a list of field names (e.g. "HasAccess") 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. "HasAccess") to include in
        	// API requests with the JSON null value. By default, fields with empty
        	// values are omitted from API requests. However, any field with an
        	// empty value appearing in NullFields will be sent to the server as
        	// null. It is an error if a field in this list has a non-empty value.
        	// This may be used to include null fields in Patch requests.
        	NullFields []string `json:"-"`
        }

        func (*CheckAccessResponse) MarshalJSON

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

        type CompositeFilter

        type CompositeFilter struct {
        	// LogicOperator: The logic operator of the sub filter.
        	//
        	// Possible values:
        	//   "AND" - Logical operators, which can only be applied to sub
        	// filters.
        	//   "OR"
        	//   "NOT" - NOT can only be applied on a single sub filter.
        	LogicOperator string `json:"logicOperator,omitempty"`
        
        	// SubFilters: Sub filters.
        	SubFilters []*Filter `json:"subFilters,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "LogicOperator") 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. "LogicOperator") to include
        	// in API requests with the JSON null value. By default, fields with
        	// empty values are omitted from API requests. However, any field with
        	// an empty value appearing in NullFields will be sent to the server as
        	// null. It is an error if a field in this list has a non-empty value.
        	// This may be used to include null fields in Patch requests.
        	NullFields []string `json:"-"`
        }

        func (*CompositeFilter) MarshalJSON

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

        type CustomerIndexStats

        type CustomerIndexStats struct {
        	// Date: Date for which statistics were calculated.
        	Date *Date `json:"date,omitempty"`
        
        	// ItemCountByStatus: Number of items aggregrated by status code.
        	ItemCountByStatus []*ItemCountByStatus `json:"itemCountByStatus,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "Date") 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. "Date") 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:"-"`
        }

          CustomerIndexStats: Aggregation of items by status code as of the specified date.

          func (*CustomerIndexStats) MarshalJSON

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

          type CustomerQueryStats

          type CustomerQueryStats struct {
          	// Date: Date for which query stats were calculated. Stats calculated on
          	// the next
          	// day close to midnight are returned.
          	Date *Date `json:"date,omitempty"`
          
          	QueryCountByStatus []*QueryCountByStatus `json:"queryCountByStatus,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Date") 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. "Date") to include in API
          	// requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*CustomerQueryStats) MarshalJSON

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

          type CustomerSessionStats

          type CustomerSessionStats struct {
          	// Date: Date for which session stats were calculated. Stats calculated
          	// on the next
          	// day close to midnight are returned.
          	Date *Date `json:"date,omitempty"`
          
          	// SearchSessionsCount: The count of search sessions on the day
          	SearchSessionsCount int64 `json:"searchSessionsCount,omitempty,string"`
          
          	// ForceSendFields is a list of field names (e.g. "Date") 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. "Date") to include in API
          	// requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*CustomerSessionStats) MarshalJSON

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

          type CustomerUserStats

          type CustomerUserStats struct {
          	// Date: Date for which session stats were calculated. Stats calculated
          	// on the next
          	// day close to midnight are returned.
          	Date *Date `json:"date,omitempty"`
          
          	// OneDayActiveUsersCount: The count of unique active users in the past
          	// one day
          	OneDayActiveUsersCount int64 `json:"oneDayActiveUsersCount,omitempty,string"`
          
          	// SevenDaysActiveUsersCount: The count of unique active users in the
          	// past seven days
          	SevenDaysActiveUsersCount int64 `json:"sevenDaysActiveUsersCount,omitempty,string"`
          
          	// ThirtyDaysActiveUsersCount: The count of unique active users in the
          	// past thirty days
          	ThirtyDaysActiveUsersCount int64 `json:"thirtyDaysActiveUsersCount,omitempty,string"`
          
          	// ForceSendFields is a list of field names (e.g. "Date") 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. "Date") to include in API
          	// requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*CustomerUserStats) MarshalJSON

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

          type DataSource

          type DataSource struct {
          	// DisableModifications: If true, Indexing API rejects any modification
          	// calls to this datasource
          	// such as create, update, and delete.
          	// Disabling this does not imply halting process of previously
          	// accepted data.
          	DisableModifications bool `json:"disableModifications,omitempty"`
          
          	// DisableServing: Disable serving any search or assist results.
          	DisableServing bool `json:"disableServing,omitempty"`
          
          	// DisplayName: Required. Display name of the datasource
          	// The maximum length is 300 characters.
          	DisplayName string `json:"displayName,omitempty"`
          
          	// IndexingServiceAccounts: List of service accounts that have indexing
          	// access.
          	IndexingServiceAccounts []string `json:"indexingServiceAccounts,omitempty"`
          
          	// ItemsVisibility: This field restricts visibility to items at the
          	// datasource level. Items
          	// within the datasource are restricted to the union of users and
          	// groups
          	// included in this field. Note that, this does not ensure access to
          	// a
          	// specific item, as users need to have ACL permissions on the
          	// contained
          	// items. This ensures a high level access on the entire datasource,
          	// and
          	// that the individual items are not shared outside this visibility.
          	ItemsVisibility []*GSuitePrincipal `json:"itemsVisibility,omitempty"`
          
          	// Name: Name of the datasource resource.
          	// Format: datasources/{source_id}.
          	// <br />The name is ignored when creating a datasource.
          	Name string `json:"name,omitempty"`
          
          	// OperationIds: IDs of the Long Running Operations (LROs) currently
          	// running for this
          	// schema.
          	OperationIds []string `json:"operationIds,omitempty"`
          
          	// ShortName: A short name or alias for the source.  This value will be
          	// used to match the
          	// 'source' operator. For example, if the short name is *&lt;value&gt;*
          	// then
          	// queries like *source:&lt;value&gt;* will only return results for
          	// this
          	// source. The value must be unique across all datasources. The value
          	// must
          	// only contain alphanumeric characters (a-zA-Z0-9). The value cannot
          	// start
          	// with 'google' and cannot be one of the following: mail, gmail, docs,
          	// drive,
          	// groups, sites, calendar, hangouts, gplus, keep, people, teams.
          	// Its maximum length is 32 characters.
          	ShortName string `json:"shortName,omitempty"`
          
          	// ServerResponse contains the HTTP response code and headers from the
          	// server.
          	googleapi.ServerResponse `json:"-"`
          
          	// ForceSendFields is a list of field names (e.g.
          	// "DisableModifications") 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. "DisableModifications") 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:"-"`
          }

            DataSource: Datasource is a logical namespace for items to be indexed. All items must belong to a datasource. This is the prerequisite before items can be indexed into Cloud Search.

            func (*DataSource) MarshalJSON

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

            type DataSourceIndexStats

            type DataSourceIndexStats struct {
            	// Date: Date for which index stats were calculated. If the date of
            	// request is not
            	// the current date then stats calculated on the next day are returned.
            	// Stats
            	// are calculated close to mid night in this case. If date of request
            	// is
            	// current date, then real time stats are returned.
            	Date *Date `json:"date,omitempty"`
            
            	// ItemCountByStatus: Number of items aggregrated by status code.
            	ItemCountByStatus []*ItemCountByStatus `json:"itemCountByStatus,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "Date") 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. "Date") 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:"-"`
            }

              DataSourceIndexStats: Aggregation of items by status code as of the specified date.

              func (*DataSourceIndexStats) MarshalJSON

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

              type DataSourceRestriction

              type DataSourceRestriction struct {
              	// FilterOptions: Filter options restricting the results. If multiple
              	// filters
              	// are present, they are grouped by object type before joining.
              	// Filters with the same object type are joined conjunctively, then
              	// the resulting expressions are joined disjunctively.
              	//
              	// The maximum number of elements is 20.
              	//
              	// NOTE: Suggest API supports only few filters at the moment:
              	//   "objecttype", "type" and "mimetype".
              	// For now, schema specific filters cannot be used to filter
              	// suggestions.
              	FilterOptions []*FilterOptions `json:"filterOptions,omitempty"`
              
              	// Source: The source of restriction.
              	Source *Source `json:"source,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "FilterOptions") 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. "FilterOptions") 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:"-"`
              }

                DataSourceRestriction: Restriction on Datasource.

                func (*DataSourceRestriction) MarshalJSON

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

                type Date

                type Date struct {
                	// Day: Day of month. Must be from 1 to 31 and valid for the year and
                	// month.
                	Day int64 `json:"day,omitempty"`
                
                	// Month: Month of date. Must be from 1 to 12.
                	Month int64 `json:"month,omitempty"`
                
                	// Year: Year of date. Must be from 1 to 9999.
                	Year int64 `json:"year,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "Day") 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. "Day") 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:"-"`
                }

                  Date: Represents a whole calendar date, for example a date of birth. The time of day and time zone are either specified elsewhere or are not significant. The date is relative to the [Proleptic Gregorian Calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar).

                  The date must be a valid calendar date between the year 1 and 9999.
                  

                  func (*Date) MarshalJSON

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

                  type DateOperatorOptions

                  type DateOperatorOptions struct {
                  	// GreaterThanOperatorName: Indicates the operator name required in the
                  	// query in order to isolate the
                  	// date property using the greater-than operator. For example,
                  	// if
                  	// greaterThanOperatorName is *closedafter* and the property's name
                  	// is
                  	// *closeDate*, then queries like *closedafter:&lt;value&gt;*
                  	// show results only where the value of the property named *closeDate*
                  	// is
                  	// later than *&lt;value&gt;*.
                  	// The operator name can only contain lowercase letters (a-z).
                  	// The maximum length is 32 characters.
                  	GreaterThanOperatorName string `json:"greaterThanOperatorName,omitempty"`
                  
                  	// LessThanOperatorName: Indicates the operator name required in the
                  	// query in order to isolate the
                  	// date property using the less-than operator. For example,
                  	// if
                  	// lessThanOperatorName is *closedbefore* and the property's name
                  	// is
                  	// *closeDate*, then queries like *closedbefore:&lt;value&gt;*
                  	// show results only where the value of the property named *closeDate*
                  	// is
                  	// earlier than *&lt;value&gt;*.
                  	// The operator name can only contain lowercase letters (a-z).
                  	// The maximum length is 32 characters.
                  	LessThanOperatorName string `json:"lessThanOperatorName,omitempty"`
                  
                  	// OperatorName: Indicates the actual string required in the query in
                  	// order to isolate the
                  	// date property. For example, suppose an issue tracking schema
                  	// object
                  	// has a property named *closeDate* that specifies an operator with
                  	// an
                  	// operatorName of *closedon*. For searches on that data, queries
                  	// like
                  	// *closedon:&lt;value&gt;* show results only where the value of
                  	// the
                  	// *closeDate* property matches *&lt;value&gt;*. By contrast, a
                  	// search that uses the same *&lt;value&gt;* without an operator
                  	// returns
                  	// all items where *&lt;value&gt;* matches the value of any
                  	// String
                  	// properties or text within the content field for the indexed
                  	// datasource.
                  	// The operator name can only contain lowercase letters (a-z).
                  	// The maximum length is 32 characters.
                  	OperatorName string `json:"operatorName,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g.
                  	// "GreaterThanOperatorName") 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. "GreaterThanOperatorName")
                  	// 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:"-"`
                  }

                    DateOperatorOptions: Optional. Provides a search operator for date properties. Search operators let users restrict the query to specific fields relevant to the type of item being searched.

                    func (*DateOperatorOptions) MarshalJSON

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

                    type DatePropertyOptions

                    type DatePropertyOptions struct {
                    	// OperatorOptions: If set, describes how the date should be used as a
                    	// search operator.
                    	OperatorOptions *DateOperatorOptions `json:"operatorOptions,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "OperatorOptions") 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. "OperatorOptions") 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:"-"`
                    }

                      DatePropertyOptions: Options for date properties.

                      func (*DatePropertyOptions) MarshalJSON

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

                      type DateValues

                      type DateValues struct {
                      	Values []*Date `json:"values,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                      }

                        DateValues: List of date values.

                        func (*DateValues) MarshalJSON

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

                        type DebugDatasourcesItemsCheckAccessCall

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

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

                          func (c *DebugDatasourcesItemsCheckAccessCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *DebugDatasourcesItemsCheckAccessCall

                            DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                            func (*DebugDatasourcesItemsCheckAccessCall) Do

                              Do executes the "cloudsearch.debug.datasources.items.checkAccess" call. Exactly one of *CheckAccessResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *CheckAccessResponse.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 (*DebugDatasourcesItemsCheckAccessCall) Fields

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

                                func (*DebugDatasourcesItemsCheckAccessCall) Header

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

                                  type DebugDatasourcesItemsSearchByViewUrlCall

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

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

                                      Do executes the "cloudsearch.debug.datasources.items.searchByViewUrl" call. Exactly one of *SearchItemsByViewUrlResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *SearchItemsByViewUrlResponse.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 (*DebugDatasourcesItemsSearchByViewUrlCall) Fields

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

                                        func (*DebugDatasourcesItemsSearchByViewUrlCall) Header

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

                                          func (*DebugDatasourcesItemsSearchByViewUrlCall) Pages

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

                                            type DebugDatasourcesItemsService

                                            type DebugDatasourcesItemsService struct {
                                            	Unmappedids *DebugDatasourcesItemsUnmappedidsService
                                            	// contains filtered or unexported fields
                                            }

                                            func NewDebugDatasourcesItemsService

                                            func NewDebugDatasourcesItemsService(s *Service) *DebugDatasourcesItemsService

                                            func (*DebugDatasourcesItemsService) CheckAccess

                                              CheckAccess: Checks whether an item is accessible by specified principal.

                                              **Note:** This API requires an admin account to execute.

                                              func (*DebugDatasourcesItemsService) SearchByViewUrl

                                              func (r *DebugDatasourcesItemsService) SearchByViewUrl(name string, searchitemsbyviewurlrequest *SearchItemsByViewUrlRequest) *DebugDatasourcesItemsSearchByViewUrlCall

                                                SearchByViewUrl: Fetches the item whose viewUrl exactly matches that of the URL provided in the request.

                                                **Note:** This API requires an admin account to execute.

                                                type DebugDatasourcesItemsUnmappedidsListCall

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

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

                                                  func (c *DebugDatasourcesItemsUnmappedidsListCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *DebugDatasourcesItemsUnmappedidsListCall

                                                    DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                    func (*DebugDatasourcesItemsUnmappedidsListCall) Do

                                                      Do executes the "cloudsearch.debug.datasources.items.unmappedids.list" call. Exactly one of *ListUnmappedIdentitiesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListUnmappedIdentitiesResponse.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 (*DebugDatasourcesItemsUnmappedidsListCall) Fields

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

                                                        func (*DebugDatasourcesItemsUnmappedidsListCall) Header

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

                                                          func (*DebugDatasourcesItemsUnmappedidsListCall) IfNoneMatch

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

                                                            func (*DebugDatasourcesItemsUnmappedidsListCall) PageSize

                                                              PageSize sets the optional parameter "pageSize": Maximum number of items to fetch in a request. Defaults to 100.

                                                              func (*DebugDatasourcesItemsUnmappedidsListCall) PageToken

                                                                PageToken sets the optional parameter "pageToken": The next_page_token value returned from a previous List request, if any.

                                                                func (*DebugDatasourcesItemsUnmappedidsListCall) Pages

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

                                                                  type DebugDatasourcesItemsUnmappedidsService

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

                                                                  func NewDebugDatasourcesItemsUnmappedidsService

                                                                  func NewDebugDatasourcesItemsUnmappedidsService(s *Service) *DebugDatasourcesItemsUnmappedidsService

                                                                  func (*DebugDatasourcesItemsUnmappedidsService) List

                                                                    List: List all unmapped identities for a specific item.

                                                                    **Note:** This API requires an admin account to execute.

                                                                    type DebugDatasourcesService

                                                                    type DebugDatasourcesService struct {
                                                                    	Items *DebugDatasourcesItemsService
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                    func NewDebugDatasourcesService

                                                                    func NewDebugDatasourcesService(s *Service) *DebugDatasourcesService

                                                                    type DebugIdentitysourcesItemsListForunmappedidentityCall

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

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

                                                                      func (c *DebugIdentitysourcesItemsListForunmappedidentityCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *DebugIdentitysourcesItemsListForunmappedidentityCall

                                                                        DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                        func (*DebugIdentitysourcesItemsListForunmappedidentityCall) Do

                                                                          Do executes the "cloudsearch.debug.identitysources.items.listForunmappedidentity" call. Exactly one of *ListItemNamesForUnmappedIdentityResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListItemNamesForUnmappedIdentityResponse.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 (*DebugIdentitysourcesItemsListForunmappedidentityCall) Fields

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

                                                                            func (*DebugIdentitysourcesItemsListForunmappedidentityCall) GroupResourceName

                                                                              GroupResourceName sets the optional parameter "groupResourceName":

                                                                              func (*DebugIdentitysourcesItemsListForunmappedidentityCall) Header

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

                                                                                func (*DebugIdentitysourcesItemsListForunmappedidentityCall) IfNoneMatch

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

                                                                                  func (*DebugIdentitysourcesItemsListForunmappedidentityCall) PageSize

                                                                                    PageSize sets the optional parameter "pageSize": Maximum number of items to fetch in a request. Defaults to 100.

                                                                                    func (*DebugIdentitysourcesItemsListForunmappedidentityCall) PageToken

                                                                                      PageToken sets the optional parameter "pageToken": The next_page_token value returned from a previous List request, if any.

                                                                                      func (*DebugIdentitysourcesItemsListForunmappedidentityCall) Pages

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

                                                                                        func (*DebugIdentitysourcesItemsListForunmappedidentityCall) UserResourceName

                                                                                          UserResourceName sets the optional parameter "userResourceName":

                                                                                          type DebugIdentitysourcesItemsService

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

                                                                                          func NewDebugIdentitysourcesItemsService

                                                                                          func NewDebugIdentitysourcesItemsService(s *Service) *DebugIdentitysourcesItemsService

                                                                                          func (*DebugIdentitysourcesItemsService) ListForunmappedidentity

                                                                                            ListForunmappedidentity: Lists names of items associated with an unmapped identity.

                                                                                            **Note:** This API requires an admin account to execute.

                                                                                            type DebugIdentitysourcesService

                                                                                            type DebugIdentitysourcesService struct {
                                                                                            	Items *DebugIdentitysourcesItemsService
                                                                                            
                                                                                            	Unmappedids *DebugIdentitysourcesUnmappedidsService
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                            func NewDebugIdentitysourcesService

                                                                                            func NewDebugIdentitysourcesService(s *Service) *DebugIdentitysourcesService

                                                                                            type DebugIdentitysourcesUnmappedidsListCall

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

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

                                                                                              func (c *DebugIdentitysourcesUnmappedidsListCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *DebugIdentitysourcesUnmappedidsListCall

                                                                                                DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                func (*DebugIdentitysourcesUnmappedidsListCall) Do

                                                                                                  Do executes the "cloudsearch.debug.identitysources.unmappedids.list" call. Exactly one of *ListUnmappedIdentitiesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListUnmappedIdentitiesResponse.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 (*DebugIdentitysourcesUnmappedidsListCall) Fields

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

                                                                                                    func (*DebugIdentitysourcesUnmappedidsListCall) Header

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

                                                                                                      func (*DebugIdentitysourcesUnmappedidsListCall) IfNoneMatch

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

                                                                                                        func (*DebugIdentitysourcesUnmappedidsListCall) PageSize

                                                                                                          PageSize sets the optional parameter "pageSize": Maximum number of items to fetch in a request. Defaults to 100.

                                                                                                          func (*DebugIdentitysourcesUnmappedidsListCall) PageToken

                                                                                                            PageToken sets the optional parameter "pageToken": The next_page_token value returned from a previous List request, if any.

                                                                                                            func (*DebugIdentitysourcesUnmappedidsListCall) Pages

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

                                                                                                              func (*DebugIdentitysourcesUnmappedidsListCall) ResolutionStatusCode

                                                                                                              func (c *DebugIdentitysourcesUnmappedidsListCall) ResolutionStatusCode(resolutionStatusCode string) *DebugIdentitysourcesUnmappedidsListCall

                                                                                                                ResolutionStatusCode sets the optional parameter "resolutionStatusCode": Limit users selection to this status.

                                                                                                                Possible values:

                                                                                                                "CODE_UNSPECIFIED"
                                                                                                                "NOT_FOUND"
                                                                                                                "IDENTITY_SOURCE_NOT_FOUND"
                                                                                                                "IDENTITY_SOURCE_MISCONFIGURED"
                                                                                                                "TOO_MANY_MAPPINGS_FOUND"
                                                                                                                "INTERNAL_ERROR"
                                                                                                                

                                                                                                                type DebugIdentitysourcesUnmappedidsService

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

                                                                                                                func NewDebugIdentitysourcesUnmappedidsService

                                                                                                                func NewDebugIdentitysourcesUnmappedidsService(s *Service) *DebugIdentitysourcesUnmappedidsService

                                                                                                                func (*DebugIdentitysourcesUnmappedidsService) List

                                                                                                                  List: Lists unmapped user identities for an identity source.

                                                                                                                  **Note:** This API requires an admin account to execute.

                                                                                                                  type DebugOptions

                                                                                                                  type DebugOptions struct {
                                                                                                                  	// EnableDebugging: If you are asked by Google to help with debugging,
                                                                                                                  	// set this field.
                                                                                                                  	// Otherwise, ignore this field.
                                                                                                                  	EnableDebugging bool `json:"enableDebugging,omitempty"`
                                                                                                                  
                                                                                                                  	// ForceSendFields is a list of field names (e.g. "EnableDebugging") 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. "EnableDebugging") 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:"-"`
                                                                                                                  }

                                                                                                                    DebugOptions: Shared request debug options for all cloudsearch RPC methods.

                                                                                                                    func (*DebugOptions) MarshalJSON

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

                                                                                                                    type DebugService

                                                                                                                    type DebugService struct {
                                                                                                                    	Datasources *DebugDatasourcesService
                                                                                                                    
                                                                                                                    	Identitysources *DebugIdentitysourcesService
                                                                                                                    	// contains filtered or unexported fields
                                                                                                                    }

                                                                                                                    func NewDebugService

                                                                                                                    func NewDebugService(s *Service) *DebugService

                                                                                                                    type DeleteQueueItemsRequest

                                                                                                                    type DeleteQueueItemsRequest struct {
                                                                                                                    	// ConnectorName: Name of connector making this call.
                                                                                                                    	// <br />Format: datasources/{source_id}/connectors/{ID}
                                                                                                                    	ConnectorName string `json:"connectorName,omitempty"`
                                                                                                                    
                                                                                                                    	// DebugOptions: Common debug options.
                                                                                                                    	DebugOptions *DebugOptions `json:"debugOptions,omitempty"`
                                                                                                                    
                                                                                                                    	// Queue: Name of a queue to delete items from.
                                                                                                                    	Queue string `json:"queue,omitempty"`
                                                                                                                    
                                                                                                                    	// ForceSendFields is a list of field names (e.g. "ConnectorName") 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. "ConnectorName") to include
                                                                                                                    	// in API requests with the JSON null value. By default, fields with
                                                                                                                    	// empty values are omitted from API requests. However, any field with
                                                                                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                    }

                                                                                                                    func (*DeleteQueueItemsRequest) MarshalJSON

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

                                                                                                                    type DisplayedProperty

                                                                                                                    type DisplayedProperty struct {
                                                                                                                    	// PropertyName: The name of the top-level property as defined in a
                                                                                                                    	// property definition
                                                                                                                    	// for the object. If the name is not a defined property in the schema,
                                                                                                                    	// an
                                                                                                                    	// error is given when attempting to update the schema.
                                                                                                                    	PropertyName string `json:"propertyName,omitempty"`
                                                                                                                    
                                                                                                                    	// ForceSendFields is a list of field names (e.g. "PropertyName") 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. "PropertyName") 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:"-"`
                                                                                                                    }

                                                                                                                      DisplayedProperty: A reference to a top-level property within the object that should be displayed in search results. The values of the chosen properties is displayed in the search results along with the display label for that property if one is specified. If a display label is not specified, only the values is shown.

                                                                                                                      func (*DisplayedProperty) MarshalJSON

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

                                                                                                                      type DoubleOperatorOptions

                                                                                                                      type DoubleOperatorOptions struct {
                                                                                                                      	// OperatorName: Indicates the operator name required in the query in
                                                                                                                      	// order to use the
                                                                                                                      	// double property in sorting or as a facet.
                                                                                                                      	// The operator name can only contain lowercase letters (a-z).
                                                                                                                      	// The maximum length is 32 characters.
                                                                                                                      	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                      
                                                                                                                      	// ForceSendFields is a list of field names (e.g. "OperatorName") 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. "OperatorName") 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:"-"`
                                                                                                                      }

                                                                                                                        DoubleOperatorOptions: Used to provide a search operator for double properties. This is optional. Search operators let users restrict the query to specific fields relevant to the type of item being searched.

                                                                                                                        func (*DoubleOperatorOptions) MarshalJSON

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

                                                                                                                        type DoublePropertyOptions

                                                                                                                        type DoublePropertyOptions struct {
                                                                                                                        	// OperatorOptions: If set, describes how the double should be used as a
                                                                                                                        	// search operator.
                                                                                                                        	OperatorOptions *DoubleOperatorOptions `json:"operatorOptions,omitempty"`
                                                                                                                        
                                                                                                                        	// ForceSendFields is a list of field names (e.g. "OperatorOptions") 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. "OperatorOptions") 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:"-"`
                                                                                                                        }

                                                                                                                          DoublePropertyOptions: Options for double properties.

                                                                                                                          func (*DoublePropertyOptions) MarshalJSON

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

                                                                                                                          type DoubleValues

                                                                                                                          type DoubleValues struct {
                                                                                                                          	Values []float64 `json:"values,omitempty"`
                                                                                                                          
                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                                                                                                                          }

                                                                                                                            DoubleValues: List of double values.

                                                                                                                            func (*DoubleValues) MarshalJSON

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

                                                                                                                            type DriveFollowUpRestrict

                                                                                                                            type DriveFollowUpRestrict struct {
                                                                                                                            	// Possible values:
                                                                                                                            	//   "UNSPECIFIED"
                                                                                                                            	//   "FOLLOWUP_SUGGESTIONS"
                                                                                                                            	//   "FOLLOWUP_ACTION_ITEMS"
                                                                                                                            	Type string `json:"type,omitempty"`
                                                                                                                            
                                                                                                                            	// ForceSendFields is a list of field names (e.g. "Type") 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. "Type") 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:"-"`
                                                                                                                            }

                                                                                                                              DriveFollowUpRestrict: Drive follow-up search restricts (e.g. "followup:suggestions").

                                                                                                                              func (*DriveFollowUpRestrict) MarshalJSON

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

                                                                                                                              type DriveLocationRestrict

                                                                                                                              type DriveLocationRestrict struct {
                                                                                                                              	// Possible values:
                                                                                                                              	//   "UNSPECIFIED"
                                                                                                                              	//   "TRASHED"
                                                                                                                              	//   "STARRED"
                                                                                                                              	Type string `json:"type,omitempty"`
                                                                                                                              
                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Type") 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. "Type") 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:"-"`
                                                                                                                              }

                                                                                                                                DriveLocationRestrict: Drive location search restricts (e.g. "is:starred").

                                                                                                                                func (*DriveLocationRestrict) MarshalJSON

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

                                                                                                                                type DriveMimeTypeRestrict

                                                                                                                                type DriveMimeTypeRestrict struct {
                                                                                                                                	// Possible values:
                                                                                                                                	//   "UNSPECIFIED"
                                                                                                                                	//   "PDF"
                                                                                                                                	//   "DOCUMENT"
                                                                                                                                	//   "PRESENTATION"
                                                                                                                                	//   "SPREADSHEET"
                                                                                                                                	//   "FORM"
                                                                                                                                	//   "DRAWING"
                                                                                                                                	//   "SCRIPT"
                                                                                                                                	//   "MAP"
                                                                                                                                	//   "IMAGE"
                                                                                                                                	//   "AUDIO"
                                                                                                                                	//   "VIDEO"
                                                                                                                                	//   "FOLDER"
                                                                                                                                	//   "ARCHIVE"
                                                                                                                                	//   "SITE"
                                                                                                                                	Type string `json:"type,omitempty"`
                                                                                                                                
                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Type") 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. "Type") 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:"-"`
                                                                                                                                }

                                                                                                                                  DriveMimeTypeRestrict: Drive mime-type search restricts (e.g. "type:pdf").

                                                                                                                                  func (*DriveMimeTypeRestrict) MarshalJSON

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

                                                                                                                                  type DriveTimeSpanRestrict

                                                                                                                                  type DriveTimeSpanRestrict struct {
                                                                                                                                  	// Possible values:
                                                                                                                                  	//   "UNSPECIFIED"
                                                                                                                                  	//   "TODAY"
                                                                                                                                  	//   "YESTERDAY"
                                                                                                                                  	//   "LAST_7_DAYS"
                                                                                                                                  	//   "LAST_30_DAYS" - Not Enabled
                                                                                                                                  	//   "LAST_90_DAYS" - Not Enabled
                                                                                                                                  	Type string `json:"type,omitempty"`
                                                                                                                                  
                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Type") 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. "Type") 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:"-"`
                                                                                                                                  }

                                                                                                                                    DriveTimeSpanRestrict: The time span search restrict (e.g. "after:2017-09-11 before:2017-09-12").

                                                                                                                                    func (*DriveTimeSpanRestrict) MarshalJSON

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

                                                                                                                                    type EmailAddress

                                                                                                                                    type EmailAddress struct {
                                                                                                                                    	// EmailAddress: The email address.
                                                                                                                                    	EmailAddress string `json:"emailAddress,omitempty"`
                                                                                                                                    
                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "EmailAddress") 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. "EmailAddress") 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:"-"`
                                                                                                                                    }

                                                                                                                                      EmailAddress: A person's email address.

                                                                                                                                      func (*EmailAddress) MarshalJSON

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

                                                                                                                                      type EnumOperatorOptions

                                                                                                                                      type EnumOperatorOptions struct {
                                                                                                                                      	// OperatorName: Indicates the operator name required in the query in
                                                                                                                                      	// order to isolate the
                                                                                                                                      	// enum property. For example, if operatorName is *priority* and
                                                                                                                                      	// the
                                                                                                                                      	// property's name is *priorityVal*, then queries
                                                                                                                                      	// like
                                                                                                                                      	// *priority:&lt;value&gt;* show results only where the value of
                                                                                                                                      	// the
                                                                                                                                      	// property named *priorityVal* matches *&lt;value&gt;*. By contrast,
                                                                                                                                      	// a
                                                                                                                                      	// search that uses the same *&lt;value&gt;* without an operator
                                                                                                                                      	// returns
                                                                                                                                      	// all items where *&lt;value&gt;* matches the value of any
                                                                                                                                      	// String
                                                                                                                                      	// properties or text within the content field for the item.
                                                                                                                                      	// The operator name can only contain lowercase letters (a-z).
                                                                                                                                      	// The maximum length is 32 characters.
                                                                                                                                      	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                                      
                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "OperatorName") 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. "OperatorName") 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:"-"`
                                                                                                                                      }

                                                                                                                                        EnumOperatorOptions: Used to provide a search operator for enum properties. This is optional. Search operators let users restrict the query to specific fields relevant to the type of item being searched. For example, if you provide no operator for a *priority* enum property with possible values *p0* and *p1*, a query that contains the term *p0* returns items that have *p0* as the value of the *priority* property, as well as any items that contain the string *p0* in other fields. If you provide an operator name for the enum, such as *priority*, then search users can use that operator to refine results to only items that have *p0* as this property's value, with the query *priority:p0*.

                                                                                                                                        func (*EnumOperatorOptions) MarshalJSON

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

                                                                                                                                        type EnumPropertyOptions

                                                                                                                                        type EnumPropertyOptions struct {
                                                                                                                                        	// OperatorOptions: If set, describes how the enum should be used as a
                                                                                                                                        	// search operator.
                                                                                                                                        	OperatorOptions *EnumOperatorOptions `json:"operatorOptions,omitempty"`
                                                                                                                                        
                                                                                                                                        	// OrderedRanking: Used to specify the ordered ranking for the
                                                                                                                                        	// enumeration that determines how
                                                                                                                                        	// the integer values provided in the possible EnumValuePairs are used
                                                                                                                                        	// to rank
                                                                                                                                        	// results. If specified, integer values must be provided for all
                                                                                                                                        	// possible
                                                                                                                                        	// EnumValuePair values given for this property. Can only be used
                                                                                                                                        	// if
                                                                                                                                        	// isRepeatable
                                                                                                                                        	// is false.
                                                                                                                                        	//
                                                                                                                                        	// Possible values:
                                                                                                                                        	//   "NO_ORDER" - There is no ranking order for the property. Results
                                                                                                                                        	// aren't adjusted
                                                                                                                                        	// by this property's value.
                                                                                                                                        	//   "ASCENDING" - This property is ranked in ascending order. Lower
                                                                                                                                        	// values indicate lower
                                                                                                                                        	// ranking.
                                                                                                                                        	//   "DESCENDING" - This property is ranked in descending order. Lower
                                                                                                                                        	// values indicate
                                                                                                                                        	// higher ranking.
                                                                                                                                        	OrderedRanking string `json:"orderedRanking,omitempty"`
                                                                                                                                        
                                                                                                                                        	// PossibleValues: The list of possible values for the enumeration
                                                                                                                                        	// property. All
                                                                                                                                        	// EnumValuePairs must provide a string value. If you specify an integer
                                                                                                                                        	// value
                                                                                                                                        	// for one EnumValuePair, then all possible EnumValuePairs must provide
                                                                                                                                        	// an
                                                                                                                                        	// integer value. Both the string value and integer value must be unique
                                                                                                                                        	// over
                                                                                                                                        	// all possible values. Once set, possible values cannot be removed
                                                                                                                                        	// or
                                                                                                                                        	// modified. If you supply an ordered ranking and think you might
                                                                                                                                        	// insert
                                                                                                                                        	// additional enum values in the future, leave gaps in the initial
                                                                                                                                        	// integer
                                                                                                                                        	// values to allow adding a value in between previously registered
                                                                                                                                        	// values.
                                                                                                                                        	// The maximum number of elements is 100.
                                                                                                                                        	PossibleValues []*EnumValuePair `json:"possibleValues,omitempty"`
                                                                                                                                        
                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "OperatorOptions") 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. "OperatorOptions") 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:"-"`
                                                                                                                                        }

                                                                                                                                          EnumPropertyOptions: Options for enum properties, which allow you to define a restricted set of strings to match user queries, set rankings for those string values, and define an operator name to be paired with those strings so that users can narrow results to only items with a specific value. For example, for items in a request tracking system with priority information, you could define *p0* as an allowable enum value and tie this enum to the operator name *priority* so that search users could add *priority:p0* to their query to restrict the set of results to only those items indexed with the value *p0*.

                                                                                                                                          func (*EnumPropertyOptions) MarshalJSON

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

                                                                                                                                          type EnumValuePair

                                                                                                                                          type EnumValuePair struct {
                                                                                                                                          	// IntegerValue: The integer value of the EnumValuePair which must be
                                                                                                                                          	// non-negative.
                                                                                                                                          	// Optional.
                                                                                                                                          	IntegerValue int64 `json:"integerValue,omitempty"`
                                                                                                                                          
                                                                                                                                          	// StringValue: The string value of the EnumValuePair.
                                                                                                                                          	// The maximum length is 32 characters.
                                                                                                                                          	StringValue string `json:"stringValue,omitempty"`
                                                                                                                                          
                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "IntegerValue") 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. "IntegerValue") 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:"-"`
                                                                                                                                          }

                                                                                                                                            EnumValuePair: The enumeration value pair defines two things: a required string value and an optional integer value. The string value defines the necessary query term required to retrieve that item, such as *p0* for a priority item. The integer value determines the ranking of that string value relative to other enumerated values for the same property. For example, you might associate *p0* with *0* and define another enum pair such as *p1* and *1*. You must use the integer value in combination with ordered ranking to set the ranking of a given value relative to other enumerated values for the same property name. Here, a ranking order of DESCENDING for *priority* properties results in a ranking boost for items indexed with a value of *p0* compared to items indexed with a value of *p1*. Without a specified ranking order, the integer value has no effect on item ranking.

                                                                                                                                            func (*EnumValuePair) MarshalJSON

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

                                                                                                                                            type EnumValues

                                                                                                                                            type EnumValues struct {
                                                                                                                                            	// Values: The maximum allowable length for string values is 32
                                                                                                                                            	// characters.
                                                                                                                                            	Values []string `json:"values,omitempty"`
                                                                                                                                            
                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                                                                                                                                            }

                                                                                                                                              EnumValues: List of enum values.

                                                                                                                                              func (*EnumValues) MarshalJSON

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

                                                                                                                                              type ErrorInfo

                                                                                                                                              type ErrorInfo struct {
                                                                                                                                              	ErrorMessages []*ErrorMessage `json:"errorMessages,omitempty"`
                                                                                                                                              
                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "ErrorMessages") 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. "ErrorMessages") 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:"-"`
                                                                                                                                              }

                                                                                                                                                ErrorInfo: Error information about the response.

                                                                                                                                                func (*ErrorInfo) MarshalJSON

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

                                                                                                                                                type ErrorMessage

                                                                                                                                                type ErrorMessage struct {
                                                                                                                                                	ErrorMessage string `json:"errorMessage,omitempty"`
                                                                                                                                                
                                                                                                                                                	Source *Source `json:"source,omitempty"`
                                                                                                                                                
                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "ErrorMessage") 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. "ErrorMessage") 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:"-"`
                                                                                                                                                }

                                                                                                                                                  ErrorMessage: Error message per source response.

                                                                                                                                                  func (*ErrorMessage) MarshalJSON

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

                                                                                                                                                  type FacetBucket

                                                                                                                                                  type FacetBucket struct {
                                                                                                                                                  	// Count: Number of results that match the bucket value. Counts are only
                                                                                                                                                  	// returned
                                                                                                                                                  	// for searches when count accuracy is ensured. Can be empty.
                                                                                                                                                  	Count int64 `json:"count,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// Percentage: Percent of results that match the bucket value. The
                                                                                                                                                  	// returned value is
                                                                                                                                                  	// between (0-100], and is rounded down to an integer if fractional. If
                                                                                                                                                  	// the
                                                                                                                                                  	// value is not explicitly returned, it represents a percentage value
                                                                                                                                                  	// that
                                                                                                                                                  	// rounds to 0. Percentages are returned for all searches, but are
                                                                                                                                                  	// an
                                                                                                                                                  	// estimate. Because percentages are always returned, you should
                                                                                                                                                  	// render
                                                                                                                                                  	// percentages instead of counts.
                                                                                                                                                  	Percentage int64 `json:"percentage,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	Value *Value `json:"value,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Count") 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. "Count") 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:"-"`
                                                                                                                                                  }

                                                                                                                                                    FacetBucket: A bucket in a facet is the basic unit of operation. A bucket can comprise either a single value OR a contiguous range of values, depending on the type of the field bucketed. FacetBucket is currently used only for returning the response object.

                                                                                                                                                    func (*FacetBucket) MarshalJSON

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

                                                                                                                                                    type FacetOptions

                                                                                                                                                    type FacetOptions struct {
                                                                                                                                                    	// NumFacetBuckets: Maximum number of facet buckets that should be
                                                                                                                                                    	// returned for this facet.
                                                                                                                                                    	// Defaults to 10.
                                                                                                                                                    	// Maximum value is 100.
                                                                                                                                                    	NumFacetBuckets int64 `json:"numFacetBuckets,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// ObjectType: If object_type is set, only those objects of that type
                                                                                                                                                    	// will be used to
                                                                                                                                                    	// compute facets. If empty, then all objects will be used to compute
                                                                                                                                                    	// facets.
                                                                                                                                                    	ObjectType string `json:"objectType,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// OperatorName: Name of the operator chosen for faceting.
                                                                                                                                                    	// @see
                                                                                                                                                    	// cloudsearch.SchemaPropertyOptions
                                                                                                                                                    	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// SourceName: Source name to facet on. Format:
                                                                                                                                                    	// datasources/{source_id}
                                                                                                                                                    	// If empty, all data sources will be used.
                                                                                                                                                    	SourceName string `json:"sourceName,omitempty"`
                                                                                                                                                    
                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "NumFacetBuckets") 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. "NumFacetBuckets") 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:"-"`
                                                                                                                                                    }

                                                                                                                                                      FacetOptions: Specifies operators to return facet results for. There will be one FacetResult for every source_name/object_type/operator_name combination.

                                                                                                                                                      func (*FacetOptions) MarshalJSON

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

                                                                                                                                                      type FacetResult

                                                                                                                                                      type FacetResult struct {
                                                                                                                                                      	// Buckets: FacetBuckets for values in response containing at least a
                                                                                                                                                      	// single result.
                                                                                                                                                      	Buckets []*FacetBucket `json:"buckets,omitempty"`
                                                                                                                                                      
                                                                                                                                                      	// ObjectType: Object type for which facet results are returned. Can be
                                                                                                                                                      	// empty.
                                                                                                                                                      	ObjectType string `json:"objectType,omitempty"`
                                                                                                                                                      
                                                                                                                                                      	// OperatorName: Name of the operator chosen for faceting.
                                                                                                                                                      	// @see
                                                                                                                                                      	// cloudsearch.SchemaPropertyOptions
                                                                                                                                                      	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                                                      
                                                                                                                                                      	// SourceName: Source name for which facet results are returned. Will
                                                                                                                                                      	// not be empty.
                                                                                                                                                      	SourceName string `json:"sourceName,omitempty"`
                                                                                                                                                      
                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Buckets") 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. "Buckets") 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:"-"`
                                                                                                                                                      }

                                                                                                                                                        FacetResult: Source specific facet response

                                                                                                                                                        func (*FacetResult) MarshalJSON

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

                                                                                                                                                        type FieldViolation

                                                                                                                                                        type FieldViolation struct {
                                                                                                                                                        	// Description: Description of the error.
                                                                                                                                                        	Description string `json:"description,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// Field: Path of field with violation.
                                                                                                                                                        	Field string `json:"field,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:"-"`
                                                                                                                                                        }

                                                                                                                                                        func (*FieldViolation) MarshalJSON

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

                                                                                                                                                        type Filter

                                                                                                                                                        type Filter struct {
                                                                                                                                                        	CompositeFilter *CompositeFilter `json:"compositeFilter,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	ValueFilter *ValueFilter `json:"valueFilter,omitempty"`
                                                                                                                                                        
                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "CompositeFilter") 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. "CompositeFilter") 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:"-"`
                                                                                                                                                        }

                                                                                                                                                          Filter: A generic way of expressing filters in a query, which supports two approaches: <br/><br/> **1. Setting a ValueFilter.** The name must match an operator_name defined in the schema for your data source. <br/> **2. Setting a CompositeFilter.** The filters are evaluated using the logical operator. The top-level operators can only be either an AND or a NOT. AND can appear only at the top-most level. OR can appear only under a top-level AND.

                                                                                                                                                          func (*Filter) MarshalJSON

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

                                                                                                                                                          type FilterOptions

                                                                                                                                                          type FilterOptions struct {
                                                                                                                                                          	// Filter: Generic filter to restrict the search, such as `lang:en`,
                                                                                                                                                          	// `site:xyz`.
                                                                                                                                                          	Filter *Filter `json:"filter,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// ObjectType: If object_type is set, only objects of that type are
                                                                                                                                                          	// returned. This should
                                                                                                                                                          	// correspond to the name of the object that was registered within
                                                                                                                                                          	// the
                                                                                                                                                          	// definition of schema. The maximum length is 256 characters.
                                                                                                                                                          	ObjectType string `json:"objectType,omitempty"`
                                                                                                                                                          
                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Filter") 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. "Filter") 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:"-"`
                                                                                                                                                          }

                                                                                                                                                            FilterOptions: Filter options to be applied on query.

                                                                                                                                                            func (*FilterOptions) MarshalJSON

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

                                                                                                                                                            type FreshnessOptions

                                                                                                                                                            type FreshnessOptions struct {
                                                                                                                                                            	// FreshnessDuration: The duration after which an object should be
                                                                                                                                                            	// considered
                                                                                                                                                            	// stale. The default value is 180 days (in seconds).
                                                                                                                                                            	FreshnessDuration string `json:"freshnessDuration,omitempty"`
                                                                                                                                                            
                                                                                                                                                            	// FreshnessProperty: This property indicates the freshness level of the
                                                                                                                                                            	// object in the index.
                                                                                                                                                            	// If set, this property must be a top-level property within
                                                                                                                                                            	// the
                                                                                                                                                            	// property definitions
                                                                                                                                                            	// and it must be a
                                                                                                                                                            	// timestamp type
                                                                                                                                                            	// or
                                                                                                                                                            	// date type.
                                                                                                                                                            	// Otherwise, the Indexing API uses
                                                                                                                                                            	// updateTime
                                                                                                                                                            	// as the freshness indicator.
                                                                                                                                                            	// The maximum length is 256 characters.
                                                                                                                                                            	//
                                                                                                                                                            	// When a property is used to calculate freshness, the value defaults
                                                                                                                                                            	// to 2 years from the current time.
                                                                                                                                                            	FreshnessProperty string `json:"freshnessProperty,omitempty"`
                                                                                                                                                            
                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "FreshnessDuration")
                                                                                                                                                            	// 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. "FreshnessDuration") 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:"-"`
                                                                                                                                                            }

                                                                                                                                                              FreshnessOptions: Indicates which freshness property to use when adjusting search ranking for an item. Fresher, more recent dates indicate higher quality. Use the freshness option property that best works with your data. For fileshare documents, last modified time is most relevant. For calendar event data, the time when the event occurs is a more relevant freshness indicator. In this way, calendar events that occur closer to the time of the search query are considered higher quality and ranked accordingly.

                                                                                                                                                              func (*FreshnessOptions) MarshalJSON

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

                                                                                                                                                              type GSuitePrincipal

                                                                                                                                                              type GSuitePrincipal struct {
                                                                                                                                                              	// GsuiteDomain: This principal represents all users of the G Suite
                                                                                                                                                              	// domain of the
                                                                                                                                                              	// customer.
                                                                                                                                                              	GsuiteDomain bool `json:"gsuiteDomain,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// GsuiteGroupEmail: This principal references a G Suite group account
                                                                                                                                                              	GsuiteGroupEmail string `json:"gsuiteGroupEmail,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// GsuiteUserEmail: This principal references a G Suite user account
                                                                                                                                                              	GsuiteUserEmail string `json:"gsuiteUserEmail,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "GsuiteDomain") 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. "GsuiteDomain") to include
                                                                                                                                                              	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                              	// empty values are omitted from API requests. However, any field with
                                                                                                                                                              	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GSuitePrincipal) MarshalJSON

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

                                                                                                                                                              type GetCustomerIndexStatsResponse

                                                                                                                                                              type GetCustomerIndexStatsResponse struct {
                                                                                                                                                              	// Stats: Summary of indexed item counts, one for each day in the
                                                                                                                                                              	// requested range.
                                                                                                                                                              	Stats []*CustomerIndexStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetCustomerIndexStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetCustomerQueryStatsResponse

                                                                                                                                                              type GetCustomerQueryStatsResponse struct {
                                                                                                                                                              	Stats []*CustomerQueryStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetCustomerQueryStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetCustomerSessionStatsResponse

                                                                                                                                                              type GetCustomerSessionStatsResponse struct {
                                                                                                                                                              	Stats []*CustomerSessionStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetCustomerSessionStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetCustomerUserStatsResponse

                                                                                                                                                              type GetCustomerUserStatsResponse struct {
                                                                                                                                                              	Stats []*CustomerUserStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetCustomerUserStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetDataSourceIndexStatsResponse

                                                                                                                                                              type GetDataSourceIndexStatsResponse struct {
                                                                                                                                                              	// Stats: Summary of indexed item counts, one for each day in the
                                                                                                                                                              	// requested range.
                                                                                                                                                              	Stats []*DataSourceIndexStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetDataSourceIndexStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetSearchApplicationQueryStatsResponse

                                                                                                                                                              type GetSearchApplicationQueryStatsResponse struct {
                                                                                                                                                              	Stats []*SearchApplicationQueryStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetSearchApplicationQueryStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetSearchApplicationSessionStatsResponse

                                                                                                                                                              type GetSearchApplicationSessionStatsResponse struct {
                                                                                                                                                              	Stats []*SearchApplicationSessionStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetSearchApplicationSessionStatsResponse) MarshalJSON

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

                                                                                                                                                              type GetSearchApplicationUserStatsResponse

                                                                                                                                                              type GetSearchApplicationUserStatsResponse struct {
                                                                                                                                                              	Stats []*SearchApplicationUserStats `json:"stats,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                              	// server.
                                                                                                                                                              	googleapi.ServerResponse `json:"-"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Stats") 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. "Stats") to include in API
                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                              }

                                                                                                                                                              func (*GetSearchApplicationUserStatsResponse) MarshalJSON

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

                                                                                                                                                              type HtmlOperatorOptions

                                                                                                                                                              type HtmlOperatorOptions struct {
                                                                                                                                                              	// OperatorName: Indicates the operator name required in the query in
                                                                                                                                                              	// order to isolate the
                                                                                                                                                              	// html property. For example, if operatorName is *subject* and
                                                                                                                                                              	// the
                                                                                                                                                              	// property's name is *subjectLine*, then queries
                                                                                                                                                              	// like
                                                                                                                                                              	// *subject:&lt;value&gt;* show results only where the value of
                                                                                                                                                              	// the
                                                                                                                                                              	// property named *subjectLine* matches *&lt;value&gt;*. By contrast,
                                                                                                                                                              	// a
                                                                                                                                                              	// search that uses the same *&lt;value&gt;* without an operator
                                                                                                                                                              	// return
                                                                                                                                                              	// all items where *&lt;value&gt;* matches the value of any
                                                                                                                                                              	// html properties or text within the content field for the item.
                                                                                                                                                              	// The operator name can only contain lowercase letters (a-z).
                                                                                                                                                              	// The maximum length is 32 characters.
                                                                                                                                                              	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "OperatorName") 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. "OperatorName") 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:"-"`
                                                                                                                                                              }

                                                                                                                                                                HtmlOperatorOptions: Used to provide a search operator for html properties. This is optional. Search operators let users restrict the query to specific fields relevant to the type of item being searched.

                                                                                                                                                                func (*HtmlOperatorOptions) MarshalJSON

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

                                                                                                                                                                type HtmlPropertyOptions

                                                                                                                                                                type HtmlPropertyOptions struct {
                                                                                                                                                                	// OperatorOptions: If set, describes how the property should be used as
                                                                                                                                                                	// a search operator.
                                                                                                                                                                	OperatorOptions *HtmlOperatorOptions `json:"operatorOptions,omitempty"`
                                                                                                                                                                
                                                                                                                                                                	// RetrievalImportance: Indicates the search quality importance of the
                                                                                                                                                                	// tokens within the
                                                                                                                                                                	// field when used for retrieval. Can only be set to DEFAULT or NONE.
                                                                                                                                                                	RetrievalImportance *RetrievalImportance `json:"retrievalImportance,omitempty"`
                                                                                                                                                                
                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "OperatorOptions") 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. "OperatorOptions") 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:"-"`
                                                                                                                                                                }

                                                                                                                                                                  HtmlPropertyOptions: Options for html properties.

                                                                                                                                                                  func (*HtmlPropertyOptions) MarshalJSON

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

                                                                                                                                                                  type HtmlValues

                                                                                                                                                                  type HtmlValues struct {
                                                                                                                                                                  	// Values: The maximum allowable length for html values is 2048
                                                                                                                                                                  	// characters.
                                                                                                                                                                  	Values []string `json:"values,omitempty"`
                                                                                                                                                                  
                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                                                                                                                                                                  }

                                                                                                                                                                    HtmlValues: List of html values.

                                                                                                                                                                    func (*HtmlValues) MarshalJSON

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

                                                                                                                                                                    type IndexItemOptions

                                                                                                                                                                    type IndexItemOptions struct {
                                                                                                                                                                    	// AllowUnknownGsuitePrincipals: Specifies if the index request should
                                                                                                                                                                    	// allow gsuite principals that do not
                                                                                                                                                                    	// exist or are deleted in the index request.
                                                                                                                                                                    	AllowUnknownGsuitePrincipals bool `json:"allowUnknownGsuitePrincipals,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g.
                                                                                                                                                                    	// "AllowUnknownGsuitePrincipals") 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.
                                                                                                                                                                    	// "AllowUnknownGsuitePrincipals") to include in API requests with the
                                                                                                                                                                    	// JSON null value. By default, fields with empty values are omitted
                                                                                                                                                                    	// from API requests. However, any field with an empty value appearing
                                                                                                                                                                    	// in NullFields will be sent to the server as null. It is an error if a
                                                                                                                                                                    	// field in this list has a non-empty value. This may be used to include
                                                                                                                                                                    	// null fields in Patch requests.
                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                    }

                                                                                                                                                                    func (*IndexItemOptions) MarshalJSON

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

                                                                                                                                                                    type IndexItemRequest

                                                                                                                                                                    type IndexItemRequest struct {
                                                                                                                                                                    	// ConnectorName: Name of connector making this call.
                                                                                                                                                                    	// <br />Format: datasources/{source_id}/connectors/{ID}
                                                                                                                                                                    	ConnectorName string `json:"connectorName,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	// DebugOptions: Common debug options.
                                                                                                                                                                    	DebugOptions *DebugOptions `json:"debugOptions,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	IndexItemOptions *IndexItemOptions `json:"indexItemOptions,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	// Item: Name of the item.
                                                                                                                                                                    	// Format:
                                                                                                                                                                    	// datasources/{source_id}/items/{item_id}
                                                                                                                                                                    	Item *Item `json:"item,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	// Mode: Required. The RequestMode for this request.
                                                                                                                                                                    	//
                                                                                                                                                                    	// Possible values:
                                                                                                                                                                    	//   "UNSPECIFIED" - Priority is not specified in the update
                                                                                                                                                                    	// request.
                                                                                                                                                                    	// Leaving priority unspecified results in an update failure.
                                                                                                                                                                    	//   "SYNCHRONOUS" - For real-time updates.
                                                                                                                                                                    	//   "ASYNCHRONOUS" - For changes that are executed after the response
                                                                                                                                                                    	// is sent back to the
                                                                                                                                                                    	// caller.
                                                                                                                                                                    	Mode string `json:"mode,omitempty"`
                                                                                                                                                                    
                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "ConnectorName") 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. "ConnectorName") to include
                                                                                                                                                                    	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                    	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                    }

                                                                                                                                                                    func (*IndexItemRequest) MarshalJSON

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

                                                                                                                                                                    type IndexingDatasourcesDeleteSchemaCall

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

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

                                                                                                                                                                      func (c *IndexingDatasourcesDeleteSchemaCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *IndexingDatasourcesDeleteSchemaCall

                                                                                                                                                                        DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                                                                                        func (*IndexingDatasourcesDeleteSchemaCall) Do

                                                                                                                                                                          Do executes the "cloudsearch.indexing.datasources.deleteSchema" 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 (*IndexingDatasourcesDeleteSchemaCall) Fields

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

                                                                                                                                                                            func (*IndexingDatasourcesDeleteSchemaCall) Header

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

                                                                                                                                                                              type IndexingDatasourcesGetSchemaCall

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

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

                                                                                                                                                                                func (c *IndexingDatasourcesGetSchemaCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *IndexingDatasourcesGetSchemaCall

                                                                                                                                                                                  DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                                                                                                  func (*IndexingDatasourcesGetSchemaCall) Do

                                                                                                                                                                                    Do executes the "cloudsearch.indexing.datasources.getSchema" call. Exactly one of *Schema or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Schema.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 (*IndexingDatasourcesGetSchemaCall) Fields

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

                                                                                                                                                                                      func (*IndexingDatasourcesGetSchemaCall) Header

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

                                                                                                                                                                                        func (*IndexingDatasourcesGetSchemaCall) IfNoneMatch

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

                                                                                                                                                                                          type IndexingDatasourcesItemsDeleteCall

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

                                                                                                                                                                                          func (*IndexingDatasourcesItemsDeleteCall) ConnectorName

                                                                                                                                                                                            ConnectorName sets the optional parameter "connectorName": Name of connector making this call. <br />Format: datasources/{source_id}/connectors/{ID}

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

                                                                                                                                                                                              func (c *IndexingDatasourcesItemsDeleteCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *IndexingDatasourcesItemsDeleteCall

                                                                                                                                                                                                DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                                                                                                                func (*IndexingDatasourcesItemsDeleteCall) Do

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

                                                                                                                                                                                                  func (*IndexingDatasourcesItemsDeleteCall) Fields

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

                                                                                                                                                                                                    func (*IndexingDatasourcesItemsDeleteCall) Header

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

                                                                                                                                                                                                      func (*IndexingDatasourcesItemsDeleteCall) Mode

                                                                                                                                                                                                        Mode sets the optional parameter "mode": Required. The RequestMode for this request.

                                                                                                                                                                                                        Possible values:

                                                                                                                                                                                                        "UNSPECIFIED"
                                                                                                                                                                                                        "SYNCHRONOUS"
                                                                                                                                                                                                        "ASYNCHRONOUS"
                                                                                                                                                                                                        

                                                                                                                                                                                                        func (*IndexingDatasourcesItemsDeleteCall) Version

                                                                                                                                                                                                          Version sets the optional parameter "version": Required. The incremented version of the item to delete from the index. The indexing system stores the version from the datasource as a byte string and compares the Item version in the index to the version of the queued Item using lexical ordering. <br /><br /> Cloud Search Indexing won't delete any queued item with a version value that is less than or equal to the version of the currently indexed item. The maximum length for this field is 1024 bytes.

                                                                                                                                                                                                          type IndexingDatasourcesItemsDeleteQueueItemsCall

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

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

                                                                                                                                                                                                              Do executes the "cloudsearch.indexing.datasources.items.deleteQueueItems" 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 (*IndexingDatasourcesItemsDeleteQueueItemsCall) Fields

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

                                                                                                                                                                                                                func (*IndexingDatasourcesItemsDeleteQueueItemsCall) Header

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

                                                                                                                                                                                                                  type IndexingDatasourcesItemsGetCall

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

                                                                                                                                                                                                                  func (*IndexingDatasourcesItemsGetCall) ConnectorName

                                                                                                                                                                                                                    ConnectorName sets the optional parameter "connectorName": Name of connector making this call. <br />Format: datasources/{source_id}/connectors/{ID}

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

                                                                                                                                                                                                                      func (c *IndexingDatasourcesItemsGetCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *IndexingDatasourcesItemsGetCall

                                                                                                                                                                                                                        DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                                                                                                                                        func (*IndexingDatasourcesItemsGetCall) Do

                                                                                                                                                                                                                          Do executes the "cloudsearch.indexing.datasources.items.get" call. Exactly one of *Item or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Item.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 (*IndexingDatasourcesItemsGetCall) Fields

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

                                                                                                                                                                                                                            func (*IndexingDatasourcesItemsGetCall) Header

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

                                                                                                                                                                                                                              func (*IndexingDatasourcesItemsGetCall) IfNoneMatch

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

                                                                                                                                                                                                                                type IndexingDatasourcesItemsIndexCall

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

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

                                                                                                                                                                                                                                    Do executes the "cloudsearch.indexing.datasources.items.index" 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 (*IndexingDatasourcesItemsIndexCall) Fields

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

                                                                                                                                                                                                                                      func (*IndexingDatasourcesItemsIndexCall) Header

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

                                                                                                                                                                                                                                        type IndexingDatasourcesItemsListCall

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

                                                                                                                                                                                                                                        func (*IndexingDatasourcesItemsListCall) Brief

                                                                                                                                                                                                                                          Brief sets the optional parameter "brief": When set to true, the indexing system only populates the following fields: name, version, queue. metadata.hash, metadata.title, metadata. sourceRepositoryURL, metadata.objectType, metadata.createTime, metadat a.updateTime, metadata.contentLanguage, metadata.mimeType, structured_ data.hash, content.hash, itemType, itemStatus.code, itemStatus.process ingError.code, itemStatus.repositoryError.type, <br />If this value is false, then all the fields are populated in Item.

                                                                                                                                                                                                                                          func (*IndexingDatasourcesItemsListCall) ConnectorName

                                                                                                                                                                                                                                            ConnectorName sets the optional parameter "connectorName": Name of connector making this call. <br />Format: datasources/{source_id}/connectors/{ID}

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

                                                                                                                                                                                                                                              func (c *IndexingDatasourcesItemsListCall) DebugOptionsEnableDebugging(debugOptionsEnableDebugging bool) *IndexingDatasourcesItemsListCall

                                                                                                                                                                                                                                                DebugOptionsEnableDebugging sets the optional parameter "debugOptions.enableDebugging": If you are asked by Google to help with debugging, set this field. Otherwise, ignore this field.

                                                                                                                                                                                                                                                func (*IndexingDatasourcesItemsListCall) Do

                                                                                                                                                                                                                                                  Do executes the "cloudsearch.indexing.datasources.items.list" call. Exactly one of *ListItemsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListItemsResponse.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 (*IndexingDatasourcesItemsListCall) Fields

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

                                                                                                                                                                                                                                                    func (*IndexingDatasourcesItemsListCall) Header

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

                                                                                                                                                                                                                                                      func (*IndexingDatasourcesItemsListCall) IfNoneMatch

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

                                                                                                                                                                                                                                                        func (*IndexingDatasourcesItemsListCall) PageSize

                                                                                                                                                                                                                                                          PageSize sets the optional parameter "pageSize": Maximum number of items to fetch in a request. The max value is 1000 when brief is true. The max value is 10 if brief is false. <br />The default value is 10

                                                                                                                                                                                                                                                          func (*IndexingDatasourcesItemsListCall) PageToken

                                                                                                                                                                                                                                                            PageToken sets the optional parameter "pageToken": The next_page_token value returned from a previous List request, if any.

                                                                                                                                                                                                                                                            func (*IndexingDatasourcesItemsListCall) Pages

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

                                                                                                                                                                                                                                                              type IndexingDatasourcesItemsPollCall

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

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

                                                                                                                                                                                                                                                                  Do executes the "cloudsearch.indexing.datasources.items.poll" call. Exactly one of *PollItemsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *PollItemsResponse.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 (*IndexingDatasourcesItemsPollCall) Fields

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

                                                                                                                                                                                                                                                                    func (*IndexingDatasourcesItemsPollCall) Header

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

                                                                                                                                                                                                                                                                      type IndexingDatasourcesItemsPushCall

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

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

                                                                                                                                                                                                                                                                          Do executes the "cloudsearch.indexing.datasources.items.push" call. Exactly one of *Item or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Item.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 (*IndexingDatasourcesItemsPushCall) Fields

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

                                                                                                                                                                                                                                                                            func (*IndexingDatasourcesItemsPushCall) Header

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

                                                                                                                                                                                                                                                                              type IndexingDatasourcesItemsService

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

                                                                                                                                                                                                                                                                              func NewIndexingDatasourcesItemsService

                                                                                                                                                                                                                                                                              func NewIndexingDatasourcesItemsService(s *Service) *IndexingDatasourcesItemsService

                                                                                                                                                                                                                                                                              func (*IndexingDatasourcesItemsService) Delete

                                                                                                                                                                                                                                                                                Delete: Deletes Item resource for the specified resource name. This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                func (*IndexingDatasourcesItemsService) DeleteQueueItems

                                                                                                                                                                                                                                                                                  DeleteQueueItems: Deletes all items in a queue. This method is useful for deleting stale items.

                                                                                                                                                                                                                                                                                  This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                  func (*IndexingDatasourcesItemsService) Get

                                                                                                                                                                                                                                                                                    Get: Gets Item resource by item name.

                                                                                                                                                                                                                                                                                    This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                    func (*IndexingDatasourcesItemsService) Index

                                                                                                                                                                                                                                                                                      Index: Updates Item ACL, metadata, and content. It will insert the Item if it does not exist. This method does not support partial updates. Fields with no provided values are cleared out in the Cloud Search index.

                                                                                                                                                                                                                                                                                      This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                      func (*IndexingDatasourcesItemsService) List

                                                                                                                                                                                                                                                                                        List: Lists all or a subset of Item resources.

                                                                                                                                                                                                                                                                                        This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                        func (*IndexingDatasourcesItemsService) Poll

                                                                                                                                                                                                                                                                                          Poll: Polls for unreserved items from the indexing queue and marks a set as reserved, starting with items that have the oldest timestamp from the highest priority ItemStatus. The priority order is as follows: <br /> ERROR <br /> MODIFIED <br /> NEW_ITEM <br /> ACCEPTED <br /> Reserving items ensures that polling from other threads cannot create overlapping sets.

                                                                                                                                                                                                                                                                                          After handling the reserved items, the client should put items back into the unreserved state, either by calling index, or by calling push with the type REQUEUE.

                                                                                                                                                                                                                                                                                          Items automatically become available (unreserved) after 4 hours even if no update or push method is called.

                                                                                                                                                                                                                                                                                          This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                          func (*IndexingDatasourcesItemsService) Push

                                                                                                                                                                                                                                                                                            Push: Pushes an item onto a queue for later polling and updating.

                                                                                                                                                                                                                                                                                            This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                            func (*IndexingDatasourcesItemsService) Unreserve

                                                                                                                                                                                                                                                                                              Unreserve: Unreserves all items from a queue, making them all eligible to be polled. This method is useful for resetting the indexing queue after a connector has been restarted.

                                                                                                                                                                                                                                                                                              This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                              func (*IndexingDatasourcesItemsService) Upload

                                                                                                                                                                                                                                                                                                Upload: Creates an upload session for uploading item content. For items smaller than 100 KB, it's easier to embed the content inline within an index request.

                                                                                                                                                                                                                                                                                                This API requires an admin or service account to execute. The service account used is the one whitelisted in the corresponding data source.

                                                                                                                                                                                                                                                                                                type IndexingDatasourcesItemsUnreserveCall

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

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

                                                                                                                                                                                                                                                                                                    Do executes the "cloudsearch.indexing.datasources.items.unreserve" 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 (*IndexingDatasourcesItemsUnreserveCall) Fields

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

                                                                                                                                                                                                                                                                                                      func (*IndexingDatasourcesItemsUnreserveCall) Header

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

                                                                                                                                                                                                                                                                                                        type IndexingDatasourcesItemsUploadCall

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

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

                                                                                                                                                                                                                                                                                                            Do executes the "cloudsearch.indexing.datasources.items.upload" call. Exactly one of *UploadItemRef or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *UploadItemRef.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 (*IndexingDatasourcesItemsUploadCall) Fields

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

                                                                                                                                                                                                                                                                                                              func (*IndexingDatasourcesItemsUploadCall) Header

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

                                                                                                                                                                                                                                                                                                                type IndexingDatasourcesService

                                                                                                                                                                                                                                                                                                                type IndexingDatasourcesService struct {
                                                                                                                                                                                                                                                                                                                	Items *IndexingDatasourcesItemsService
                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                func NewIndexingDatasourcesService

                                                                                                                                                                                                                                                                                                                func NewIndexingDatasourcesService(s *Service) *IndexingDatasourcesService

                                                                                                                                                                                                                                                                                                                func (*IndexingDatasourcesService) DeleteSchema

                                                                                                                                                                                                                                                                                                                  DeleteSchema: Deletes the schema of a data source.

                                                                                                                                                                                                                                                                                                                  **Note:** This API requires an admin or service account to execute.

                                                                                                                                                                                                                                                                                                                  func (*IndexingDatasourcesService) GetSchema

                                                                                                                                                                                                                                                                                                                    GetSchema: Gets the schema of a data source.

                                                                                                                                                                                                                                                                                                                    **Note:** This API requires an admin or service account to execute.

                                                                                                                                                                                                                                                                                                                    func (*IndexingDatasourcesService) UpdateSchema

                                                                                                                                                                                                                                                                                                                      UpdateSchema: Updates the schema of a data source. This method does not perform incremental updates to the schema. Instead, this method updates the schema by overwriting the entire schema.

                                                                                                                                                                                                                                                                                                                      **Note:** This API requires an admin or service account to execute.

                                                                                                                                                                                                                                                                                                                      type IndexingDatasourcesUpdateSchemaCall

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

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

                                                                                                                                                                                                                                                                                                                          Do executes the "cloudsearch.indexing.datasources.updateSchema" 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 (*IndexingDatasourcesUpdateSchemaCall) Fields

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

                                                                                                                                                                                                                                                                                                                            func (*IndexingDatasourcesUpdateSchemaCall) Header

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

                                                                                                                                                                                                                                                                                                                              type IndexingService

                                                                                                                                                                                                                                                                                                                              type IndexingService struct {
                                                                                                                                                                                                                                                                                                                              	Datasources *IndexingDatasourcesService
                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                              func NewIndexingService

                                                                                                                                                                                                                                                                                                                              func NewIndexingService(s *Service) *IndexingService

                                                                                                                                                                                                                                                                                                                              type IntegerOperatorOptions

                                                                                                                                                                                                                                                                                                                              type IntegerOperatorOptions struct {
                                                                                                                                                                                                                                                                                                                              	// GreaterThanOperatorName: Indicates the operator name required in the
                                                                                                                                                                                                                                                                                                                              	// query in order to isolate the
                                                                                                                                                                                                                                                                                                                              	// integer property using the greater-than operator. For example,
                                                                                                                                                                                                                                                                                                                              	// if
                                                                                                                                                                                                                                                                                                                              	// greaterThanOperatorName is *priorityabove* and the property's name
                                                                                                                                                                                                                                                                                                                              	// is
                                                                                                                                                                                                                                                                                                                              	// *priorityVal*, then queries like *priorityabove:&lt;value&gt;*
                                                                                                                                                                                                                                                                                                                              	// show results only where the value of the property named *priorityVal*
                                                                                                                                                                                                                                                                                                                              	// is
                                                                                                                                                                                                                                                                                                                              	// greater than *&lt;value&gt;*.
                                                                                                                                                                                                                                                                                                                              	// The operator name can only contain lowercase letters (a-z).
                                                                                                                                                                                                                                                                                                                              	// The maximum length is 32 characters.
                                                                                                                                                                                                                                                                                                                              	GreaterThanOperatorName string `json:"greaterThanOperatorName,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// LessThanOperatorName: Indicates the operator name required in the
                                                                                                                                                                                                                                                                                                                              	// query in order to isolate the
                                                                                                                                                                                                                                                                                                                              	// integer property using the less-than operator. For example,
                                                                                                                                                                                                                                                                                                                              	// if
                                                                                                                                                                                                                                                                                                                              	// lessThanOperatorName is *prioritybelow* and the property's name
                                                                                                                                                                                                                                                                                                                              	// is
                                                                                                                                                                                                                                                                                                                              	// *priorityVal*, then queries like *prioritybelow:&lt;value&gt;*
                                                                                                                                                                                                                                                                                                                              	// show results only where the value of the property named *priorityVal*
                                                                                                                                                                                                                                                                                                                              	// is
                                                                                                                                                                                                                                                                                                                              	// less than *&lt;value&gt;*.
                                                                                                                                                                                                                                                                                                                              	// The operator name can only contain lowercase letters (a-z).
                                                                                                                                                                                                                                                                                                                              	// The maximum length is 32 characters.
                                                                                                                                                                                                                                                                                                                              	LessThanOperatorName string `json:"lessThanOperatorName,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// OperatorName: Indicates the operator name required in the query in
                                                                                                                                                                                                                                                                                                                              	// order to isolate the
                                                                                                                                                                                                                                                                                                                              	// integer property. For example, if operatorName is *priority* and
                                                                                                                                                                                                                                                                                                                              	// the
                                                                                                                                                                                                                                                                                                                              	// property's name is *priorityVal*, then queries
                                                                                                                                                                                                                                                                                                                              	// like
                                                                                                                                                                                                                                                                                                                              	// *priority:&lt;value&gt;* show results only where the value of
                                                                                                                                                                                                                                                                                                                              	// the
                                                                                                                                                                                                                                                                                                                              	// property named *priorityVal* matches *&lt;value&gt;*. By contrast,
                                                                                                                                                                                                                                                                                                                              	// a
                                                                                                                                                                                                                                                                                                                              	// search that uses the same *&lt;value&gt;* without an operator
                                                                                                                                                                                                                                                                                                                              	// returns
                                                                                                                                                                                                                                                                                                                              	// all items where *&lt;value&gt;* matches the value of any
                                                                                                                                                                                                                                                                                                                              	// String
                                                                                                                                                                                                                                                                                                                              	// properties or text within the content field for the item.
                                                                                                                                                                                                                                                                                                                              	// The operator name can only contain lowercase letters (a-z).
                                                                                                                                                                                                                                                                                                                              	// The maximum length is 32 characters.
                                                                                                                                                                                                                                                                                                                              	OperatorName string `json:"operatorName,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g.
                                                                                                                                                                                                                                                                                                                              	// "GreaterThanOperatorName") 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. "GreaterThanOperatorName")
                                                                                                                                                                                                                                                                                                                              	// 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:"-"`
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                IntegerOperatorOptions: Used to provide a search operator for integer properties. This is optional. Search operators let users restrict the query to specific fields relevant to the type of item being searched.

                                                                                                                                                                                                                                                                                                                                func (*IntegerOperatorOptions) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                type IntegerPropertyOptions

                                                                                                                                                                                                                                                                                                                                type IntegerPropertyOptions struct {
                                                                                                                                                                                                                                                                                                                                	// MaximumValue: The maximum value of the property. The minimum and
                                                                                                                                                                                                                                                                                                                                	// maximum values for the
                                                                                                                                                                                                                                                                                                                                	// property are used to rank results according to the
                                                                                                                                                                                                                                                                                                                                	// ordered ranking.
                                                                                                                                                                                                                                                                                                                                	// Indexing requests with values greater than the maximum are accepted
                                                                                                                                                                                                                                                                                                                                	// and
                                                                                                                                                                                                                                                                                                                                	// ranked with the same weight as items indexed with the maximum value.
                                                                                                                                                                                                                                                                                                                                	MaximumValue int64 `json:"maximumValue,omitempty,string"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// MinimumValue: The minimum value of the property. The minimum and
                                                                                                                                                                                                                                                                                                                                	// maximum values for the
                                                                                                                                                                                                                                                                                                                                	// property are used to rank results according to the
                                                                                                                                                                                                                                                                                                                                	// ordered ranking.
                                                                                                                                                                                                                                                                                                                                	// Indexing requests with values less than the minimum are accepted
                                                                                                                                                                                                                                                                                                                                	// and
                                                                                                                                                                                                                                                                                                                                	// ranked with the same weight as items indexed with the minimum value.
                                                                                                                                                                                                                                                                                                                                	MinimumValue int64 `json:"minimumValue,omitempty,string"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// OperatorOptions: If set, describes how the integer should be used as
                                                                                                                                                                                                                                                                                                                                	// a search operator.
                                                                                                                                                                                                                                                                                                                                	OperatorOptions *IntegerOperatorOptions `json:"operatorOptions,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// OrderedRanking: Used to specify the ordered ranking for the integer.
                                                                                                                                                                                                                                                                                                                                	// Can only be used if
                                                                                                                                                                                                                                                                                                                                	// isRepeatable
                                                                                                                                                                                                                                                                                                                                	// is false.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// Possible values:
                                                                                                                                                                                                                                                                                                                                	//   "NO_ORDER" - There is no ranking order for the property. Results
                                                                                                                                                                                                                                                                                                                                	// are not adjusted
                                                                                                                                                                                                                                                                                                                                	// by this property's value.
                                                                                                                                                                                                                                                                                                                                	//   "ASCENDING" - This property is ranked in ascending order. Lower
                                                                                                                                                                                                                                                                                                                                	// values indicate lower
                                                                                                                                                                                                                                                                                                                                	// ranking.
                                                                                                                                                                                                                                                                                                                                	//   "DESCENDING" - This property is ranked in descending order. Lower
                                                                                                                                                                                                                                                                                                                                	// values indicate
                                                                                                                                                                                                                                                                                                                                	// higher ranking.
                                                                                                                                                                                                                                                                                                                                	OrderedRanking string `json:"orderedRanking,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "MaximumValue") 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. "MaximumValue") 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:"-"`
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  IntegerPropertyOptions: Options for integer properties.

                                                                                                                                                                                                                                                                                                                                  func (*IntegerPropertyOptions) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                  type IntegerValues

                                                                                                                                                                                                                                                                                                                                  type IntegerValues struct {
                                                                                                                                                                                                                                                                                                                                  	Values googleapi.Int64s `json:"values,omitempty"`
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    IntegerValues: List of integer values.

                                                                                                                                                                                                                                                                                                                                    func (*IntegerValues) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                    type Interaction

                                                                                                                                                                                                                                                                                                                                    type Interaction struct {
                                                                                                                                                                                                                                                                                                                                    	// InteractionTime: The time when the user acted on the item.  If
                                                                                                                                                                                                                                                                                                                                    	// multiple actions of the same
                                                                                                                                                                                                                                                                                                                                    	// type exist for a single user, only the most recent action is
                                                                                                                                                                                                                                                                                                                                    	// recorded.
                                                                                                                                                                                                                                                                                                                                    	InteractionTime string `json:"interactionTime,omitempty"`
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// Principal: The user that acted on the item.
                                                                                                                                                                                                                                                                                                                                    	Principal *Principal `json:"principal,omitempty"`
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// Possible values:
                                                                                                                                                                                                                                                                                                                                    	//   "UNSPECIFIED" - Invalid value.
                                                                                                                                                                                                                                                                                                                                    	//   "VIEW" - This interaction indicates the user viewed the item.
                                                                                                                                                                                                                                                                                                                                    	//   "EDIT" - This interaction indicates the user edited the item.
                                                                                                                                                                                                                                                                                                                                    	Type string `json:"type,omitempty"`
                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "InteractionTime") 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. "InteractionTime") 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:"-"`
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      Interaction: Represents an interaction between a user and an item.

                                                                                                                                                                                                                                                                                                                                      func (*Interaction) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                      type Item

                                                                                                                                                                                                                                                                                                                                      type Item struct {
                                                                                                                                                                                                                                                                                                                                      	// Acl: Access control list for this item.
                                                                                                                                                                                                                                                                                                                                      	Acl *ItemAcl `json:"acl,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Content: Item content to be indexed and made text searchable.
                                                                                                                                                                                                                                                                                                                                      	Content *ItemContent `json:"content,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// ItemType: Type for this item.
                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                      	// Possible values:
                                                                                                                                                                                                                                                                                                                                      	//   "UNSPECIFIED"
                                                                                                                                                                                                                                                                                                                                      	//   "CONTENT_ITEM" - An item that is indexed for the only purpose of
                                                                                                                                                                                                                                                                                                                                      	// serving information.
                                                                                                                                                                                                                                                                                                                                      	// These items cannot be referred in
                                                                                                                                                                                                                                                                                                                                      	// containerName
                                                                                                                                                                                                                                                                                                                                      	// or inheritAclFrom
                                                                                                                                                                                                                                                                                                                                      	// fields.
                                                                                                                                                                                                                                                                                                                                      	//   "CONTAINER_ITEM" - An item that gets indexed and whose purpose is
                                                                                                                                                                                                                                                                                                                                      	// to supply other items
                                                                                                                                                                                                                                                                                                                                      	// with ACLs and/or contain other items.
                                                                                                                                                                                                                                                                                                                                      	//   "VIRTUAL_CONTAINER_ITEM" - An item that does not get indexed, but
                                                                                                                                                                                                                                                                                                                                      	// otherwise has the same purpose
                                                                                                                                                                                                                                                                                                                                      	// as CONTAINER_ITEM.
                                                                                                                                                                                                                                                                                                                                      	ItemType string `json:"itemType,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Metadata: Metadata information.
                                                                                                                                                                                                                                                                                                                                      	Metadata *ItemMetadata `json:"metadata,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Name: Name of the Item.
                                                                                                                                                                                                                                                                                                                                      	// Format:
                                                                                                                                                                                                                                                                                                                                      	// datasources/{source_id}/items/{item_id}
                                                                                                                                                                                                                                                                                                                                      	// <br />This is a required field.
                                                                                                                                                                                                                                                                                                                                      	// The maximum length is 1536 characters.
                                                                                                                                                                                                                                                                                                                                      	Name string `json:"name,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Payload: Additional state connector can store for this item.
                                                                                                                                                                                                                                                                                                                                      	// The maximum length is 10000 bytes.
                                                                                                                                                                                                                                                                                                                                      	Payload string `json:"payload,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Queue: Queue this item belongs to.
                                                                                                                                                                                                                                                                                                                                      	// The maximum length is 100 characters.
                                                                                                                                                                                                                                                                                                                                      	Queue string `json:"queue,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Status: Status of the item.
                                                                                                                                                                                                                                                                                                                                      	// Output only field.
                                                                                                                                                                                                                                                                                                                                      	Status *ItemStatus `json:"status,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// StructuredData: The structured data for the item that should conform
                                                                                                                                                                                                                                                                                                                                      	// to a registered
                                                                                                                                                                                                                                                                                                                                      	// object definition in the schema for the data source.
                                                                                                                                                                                                                                                                                                                                      	StructuredData *ItemStructuredData `json:"structuredData,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// Version: Required. The indexing system stores the version from the
                                                                                                                                                                                                                                                                                                                                      	// datasource as a
                                                                                                                                                                                                                                                                                                                                      	// byte string and compares the Item version in the index
                                                                                                                                                                                                                                                                                                                                      	// to the version of the queued Item using lexical ordering.
                                                                                                                                                                                                                                                                                                                                      	// <br /><br />
                                                                                                                                                                                                                                                                                                                                      	// Cloud Search Indexing won't index or delete any queued item with
                                                                                                                                                                                                                                                                                                                                      	// a version value that is less than or equal to the version of
                                                                                                                                                                                                                                                                                                                                      	// the
                                                                                                                                                                                                                                                                                                                                      	// currently indexed item.
                                                                                                                                                                                                                                                                                                                                      	// The maximum length for this field is 1024 bytes.
                                                                                                                                                                                                                                                                                                                                      	Version string `json:"version,omitempty"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                      	// server.
                                                                                                                                                                                                                                                                                                                                      	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Acl") 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. "Acl") 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:"-"`
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        Item: Represents a single object that is an item in the search index, such as a file, folder, or a database record.

                                                                                                                                                                                                                                                                                                                                        func (*Item) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                        type ItemAcl

                                                                                                                                                                                                                                                                                                                                        type ItemAcl struct {
                                                                                                                                                                                                                                                                                                                                        	// AclInheritanceType: Sets the type of access rules to apply when an
                                                                                                                                                                                                                                                                                                                                        	// item inherits its ACL from a
                                                                                                                                                                                                                                                                                                                                        	// parent. This should always be set in tandem with
                                                                                                                                                                                                                                                                                                                                        	// the
                                                                                                                                                                                                                                                                                                                                        	// inheritAclFrom
                                                                                                                                                                                                                                                                                                                                        	// field. Also, when the
                                                                                                                                                                                                                                                                                                                                        	// inheritAclFrom field
                                                                                                                                                                                                                                                                                                                                        	// is set, this field should be set to a valid AclInheritanceType.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// Possible values:
                                                                                                                                                                                                                                                                                                                                        	//   "NOT_APPLICABLE" - The default value when this item does not
                                                                                                                                                                                                                                                                                                                                        	// inherit an ACL.
                                                                                                                                                                                                                                                                                                                                        	// Use NOT_APPLICABLE when
                                                                                                                                                                                                                                                                                                                                        	// inheritAclFrom
                                                                                                                                                                                                                                                                                                                                        	// is empty.  An item without ACL inheritance can still have ACLs
                                                                                                                                                                                                                                                                                                                                        	// supplied
                                                                                                                                                                                                                                                                                                                                        	// by its own readers and
                                                                                                                                                                                                                                                                                                                                        	// deniedReaders fields.
                                                                                                                                                                                                                                                                                                                                        	//   "CHILD_OVERRIDE" - During an authorization conflict, the ACL of the
                                                                                                                                                                                                                                                                                                                                        	// child item determines
                                                                                                                                                                                                                                                                                                                                        	// its read access.
                                                                                                                                                                                                                                                                                                                                        	//   "PARENT_OVERRIDE" - During an authorization conflict, the ACL of
                                                                                                                                                                                                                                                                                                                                        	// the parent item
                                                                                                                                                                                                                                                                                                                                        	// specified in the
                                                                                                                                                                                                                                                                                                                                        	// inheritAclFrom
                                                                                                                                                                                                                                                                                                                                        	// field determines read access.
                                                                                                                                                                                                                                                                                                                                        	//   "BOTH_PERMIT" - Access is granted only if this item and the parent
                                                                                                                                                                                                                                                                                                                                        	// item specified in
                                                                                                                                                                                                                                                                                                                                        	// the inheritAclFrom
                                                                                                                                                                                                                                                                                                                                        	// field both permit read access.
                                                                                                                                                                                                                                                                                                                                        	AclInheritanceType string `json:"aclInheritanceType,omitempty"`
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// DeniedReaders: List of principals who are explicitly denied access to
                                                                                                                                                                                                                                                                                                                                        	// the item in search
                                                                                                                                                                                                                                                                                                                                        	// results. While principals are denied access by default, use denied
                                                                                                                                                                                                                                                                                                                                        	// readers
                                                                                                                                                                                                                                                                                                                                        	// to handle exceptions and override the list allowed readers.
                                                                                                                                                                                                                                                                                                                                        	// The maximum number of elements is 100.
                                                                                                                                                                                                                                                                                                                                        	DeniedReaders []*Principal `json:"deniedReaders,omitempty"`
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// InheritAclFrom: Name of the item to inherit the Access Permission
                                                                                                                                                                                                                                                                                                                                        	// List (ACL) from.
                                                                                                                                                                                                                                                                                                                                        	// Note: ACL inheritance *only* provides access permissions
                                                                                                                                                                                                                                                                                                                                        	// to child items and does not define structural relationships, nor does
                                                                                                                                                                                                                                                                                                                                        	// it
                                                                                                                                                                                                                                                                                                                                        	// provide convenient ways to delete large groups of items.
                                                                                                                                                                                                                                                                                                                                        	// Deleting an ACL parent from the index only alters the access
                                                                                                                                                                                                                                                                                                                                        	// permissions of
                                                                                                                                                                                                                                                                                                                                        	// child items that reference the parent in the
                                                                                                                                                                                                                                                                                                                                        	// inheritAclFrom
                                                                                                                                                                                                                                                                                                                                        	// field. The item is still in the index, but may not
                                                                                                                                                                                                                                                                                                                                        	// visible in search results. By contrast, deletion of a container
                                                                                                                                                                                                                                                                                                                                        	// item
                                                                                                                                                                                                                                                                                                                                        	// also deletes all items that reference the container via
                                                                                                                                                                                                                                                                                                                                        	// the
                                                                                                                                                                                                                                                                                                                                        	// containerName
                                                                                                                                                                                                                                                                                                                                        	// field.
                                                                                                                                                                                                                                                                                                                                        	// The maximum length for this field is 1536 characters.
                                                                                                                                                                                                                                                                                                                                        	InheritAclFrom string `json:"inheritAclFrom,omitempty"`
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Owners: Optional. List of owners for the item. This field has no
                                                                                                                                                                                                                                                                                                                                        	// bearing on
                                                                                                                                                                                                                                                                                                                                        	// document access permissions. It does, however, offer
                                                                                                                                                                                                                                                                                                                                        	// a slight ranking boosts items where the querying user is an
                                                                                                                                                                                                                                                                                                                                        	// owner.
                                                                                                                                                                                                                                                                                                                                        	// The maximum number of elements is 5.
                                                                                                                                                                                                                                                                                                                                        	Owners []*Principal `json:"owners,omitempty"`
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Readers: List of principals who are allowed to see the item in search
                                                                                                                                                                                                                                                                                                                                        	// results.
                                                                                                                                                                                                                                                                                                                                        	// Optional if inheriting permissions from another item or if the
                                                                                                                                                                                                                                                                                                                                        	// item
                                                                                                                                                                                                                                                                                                                                        	// is not intended to be visible, such as
                                                                                                                                                                                                                                                                                                                                        	// virtual
                                                                                                                                                                                                                                                                                                                                        	// containers.
                                                                                                                                                                                                                                                                                                                                        	// The maximum number of elements is 1000.
                                                                                                                                                                                                                                                                                                                                        	Readers []*Principal `json:"readers,omitempty"`
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "AclInheritanceType")
                                                                                                                                                                                                                                                                                                                                        	// 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. "AclInheritanceType") 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:"-"`
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          ItemAcl: Access control list information for the item. For more information see [Map ACLs](/cloud-search/docs/guides/acls).

                                                                                                                                                                                                                                                                                                                                          func (*ItemAcl) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                          type ItemContent

                                                                                                                                                                                                                                                                                                                                          type ItemContent struct {
                                                                                                                                                                                                                                                                                                                                          	// ContentDataRef: Upload reference ID of a previously uploaded content
                                                                                                                                                                                                                                                                                                                                          	// via write method.
                                                                                                                                                                                                                                                                                                                                          	ContentDataRef *UploadItemRef `json:"contentDataRef,omitempty"`
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Possible values:
                                                                                                                                                                                                                                                                                                                                          	//   "UNSPECIFIED" - Invalid value.
                                                                                                                                                                                                                                                                                                                                          	//   "HTML" - contentFormat is HTML.
                                                                                                                                                                                                                                                                                                                                          	//   "TEXT" - contentFormat is free text.
                                                                                                                                                                                                                                                                                                                                          	//   "RAW" - contentFormat is raw bytes.
                                                                                                                                                                                                                                                                                                                                          	ContentFormat string `json:"contentFormat,omitempty"`
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// Hash: Hashing info calculated and provided by the API client for
                                                                                                                                                                                                                                                                                                                                          	// content.
                                                                                                                                                                                                                                                                                                                                          	// Can be used with the items.push method to calculate modified
                                                                                                                                                                                                                                                                                                                                          	// state.
                                                                                                                                                                                                                                                                                                                                          	// The maximum length is 2048 characters.
                                                                                                                                                                                                                                                                                                                                          	Hash string `json:"hash,omitempty"`
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// InlineContent: Content that is supplied inlined within the update
                                                                                                                                                                                                                                                                                                                                          	// method.
                                                                                                                                                                                                                                                                                                                                          	// The maximum length is 102400 bytes (100 KiB).
                                                                                                                                                                                                                                                                                                                                          	InlineContent string `json:"inlineContent,omitempty"`
                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "ContentDataRef") 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. "ContentDataRef") 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:"-"`
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            ItemContent: Content of an item to be indexed and surfaced by Cloud Search.

                                                                                                                                                                                                                                                                                                                                            func (*ItemContent) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                            type ItemCountByStatus

                                                                                                                                                                                                                                                                                                                                            type ItemCountByStatus struct {
                                                                                                                                                                                                                                                                                                                                            	// Count: Number of items matching the status code.
                                                                                                                                                                                                                                                                                                                                            	Count int64 `json:"count,omitempty,string"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// StatusCode: Status of the items.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// Possible values:
                                                                                                                                                                                                                                                                                                                                            	//   "CODE_UNSPECIFIED" - Input-only value.  Used with
                                                                                                                                                                                                                                                                                                                                            	// Items.list
                                                                                                                                                                                                                                                                                                                                            	// to list all items in the queue, regardless of status.
                                                                                                                                                                                                                                                                                                                                            	//   "ERROR" - Error encountered by Cloud Search while processing this
                                                                                                                                                                                                                                                                                                                                            	// item.
                                                                                                                                                                                                                                                                                                                                            	// Details of the error are in
                                                                                                                                                                                                                                                                                                                                            	// repositoryError.
                                                                                                                                                                                                                                                                                                                                            	//   "MODIFIED" - Item has been modified in the repository, and is out
                                                                                                                                                                                                                                                                                                                                            	// of date with
                                                                                                                                                                                                                                                                                                                                            	// the version previously accepted into Cloud Search.
                                                                                                                                                                                                                                                                                                                                            	//   "NEW_ITEM" - Item is known to exist in the repository, but is not
                                                                                                                                                                                                                                                                                                                                            	// yet accepted by
                                                                                                                                                                                                                                                                                                                                            	// Cloud Search.
                                                                                                                                                                                                                                                                                                                                            	// An item can be in this state when
                                                                                                                                                                                                                                                                                                                                            	// Items.push
                                                                                                                                                                                                                                                                                                                                            	// has been called for
                                                                                                                                                                                                                                                                                                                                            	// an item of this name that did not exist previously.
                                                                                                                                                                                                                                                                                                                                            	//   "ACCEPTED" - API has accepted the up-to-date data of this item.
                                                                                                                                                                                                                                                                                                                                            	StatusCode string `json:"statusCode,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "Count") 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. "Count") to include in API
                                                                                                                                                                                                                                                                                                                                            	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                                                                                                                                            	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                                                                                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                            func (*ItemCountByStatus) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                            type ItemMetadata

                                                                                                                                                                                                                                                                                                                                            type ItemMetadata struct {
                                                                                                                                                                                                                                                                                                                                            	// ContainerName: The name of the container for this item.
                                                                                                                                                                                                                                                                                                                                            	// Deletion of the container item leads to automatic deletion of
                                                                                                                                                                                                                                                                                                                                            	// this
                                                                                                                                                                                                                                                                                                                                            	// item.  Note: ACLs are not inherited from a container item.
                                                                                                                                                                                                                                                                                                                                            	// To provide ACL inheritance for an item, use the
                                                                                                                                                                                                                                                                                                                                            	// inheritAclFrom
                                                                                                                                                                                                                                                                                                                                            	// field. The maximum length is 1536 characters.
                                                                                                                                                                                                                                                                                                                                            	ContainerName string `json:"containerName,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// ContentLanguage: The BCP-47 language code for the item, such as
                                                                                                                                                                                                                                                                                                                                            	// "en-US" or "sr-Latn". For
                                                                                                                                                                                                                                                                                                                                            	// more information,
                                                                                                                                                                                                                                                                                                                                            	// see
                                                                                                                                                                                                                                                                                                                                            	// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
                                                                                                                                                                                                                                                                                                                                            	// Th
                                                                                                                                                                                                                                                                                                                                            	// e maximum length is 32 characters.
                                                                                                                                                                                                                                                                                                                                            	ContentLanguage string `json:"contentLanguage,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// CreateTime: The time when the item was created in the source
                                                                                                                                                                                                                                                                                                                                            	// repository.
                                                                                                                                                                                                                                                                                                                                            	CreateTime string `json:"createTime,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Hash: Hashing value provided by the API caller.
                                                                                                                                                                                                                                                                                                                                            	// This can be used with the
                                                                                                                                                                                                                                                                                                                                            	// items.push
                                                                                                                                                                                                                                                                                                                                            	// method to calculate modified state.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 2048 characters.
                                                                                                                                                                                                                                                                                                                                            	Hash string `json:"hash,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Interactions: A list of interactions for the item.  Interactions are
                                                                                                                                                                                                                                                                                                                                            	// used to improve
                                                                                                                                                                                                                                                                                                                                            	// Search quality, but are not exposed to end users.
                                                                                                                                                                                                                                                                                                                                            	// The maximum number of elements is 1000.
                                                                                                                                                                                                                                                                                                                                            	Interactions []*Interaction `json:"interactions,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Keywords: Additional keywords or phrases that should match the
                                                                                                                                                                                                                                                                                                                                            	// item.
                                                                                                                                                                                                                                                                                                                                            	// Used internally for user generated content.
                                                                                                                                                                                                                                                                                                                                            	// The maximum number of elements is 100.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 8192 characters.
                                                                                                                                                                                                                                                                                                                                            	Keywords []string `json:"keywords,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// MimeType: The original mime-type of
                                                                                                                                                                                                                                                                                                                                            	// ItemContent.content
                                                                                                                                                                                                                                                                                                                                            	// in the source repository.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 256 characters.
                                                                                                                                                                                                                                                                                                                                            	MimeType string `json:"mimeType,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// ObjectType: The type of the item.  This should correspond to the name
                                                                                                                                                                                                                                                                                                                                            	// of an object
                                                                                                                                                                                                                                                                                                                                            	// definition in the schema registered for the data source.  For
                                                                                                                                                                                                                                                                                                                                            	// example, if
                                                                                                                                                                                                                                                                                                                                            	// the schema for the data source contains an object definition with
                                                                                                                                                                                                                                                                                                                                            	// name
                                                                                                                                                                                                                                                                                                                                            	// 'document', then item indexing requests for objects of that type
                                                                                                                                                                                                                                                                                                                                            	// should set
                                                                                                                                                                                                                                                                                                                                            	// objectType to 'document'.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 256 characters.
                                                                                                                                                                                                                                                                                                                                            	ObjectType string `json:"objectType,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// SearchQualityMetadata: Additional search quality metadata of the item
                                                                                                                                                                                                                                                                                                                                            	SearchQualityMetadata *SearchQualityMetadata `json:"searchQualityMetadata,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// SourceRepositoryUrl: Link to the source repository serving the data.
                                                                                                                                                                                                                                                                                                                                            	// &#83;earch results apply
                                                                                                                                                                                                                                                                                                                                            	// this link to the title.
                                                                                                                                                                                                                                                                                                                                            	// Whitespace or special characters may cause Cloud &#83;earch result
                                                                                                                                                                                                                                                                                                                                            	// links to
                                                                                                                                                                                                                                                                                                                                            	// trigger a redirect notice; to avoid this, encode the URL.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 2048 characters.
                                                                                                                                                                                                                                                                                                                                            	SourceRepositoryUrl string `json:"sourceRepositoryUrl,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// Title: The title of the item.  If given, this will be the displayed
                                                                                                                                                                                                                                                                                                                                            	// title of the
                                                                                                                                                                                                                                                                                                                                            	// Search result.
                                                                                                                                                                                                                                                                                                                                            	// The maximum length is 2048 characters.
                                                                                                                                                                                                                                                                                                                                            	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// UpdateTime: The time when the item was last modified in the source
                                                                                                                                                                                                                                                                                                                                            	// repository.
                                                                                                                                                                                                                                                                                                                                            	UpdateTime string `json:"updateTime,omitempty"`
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "ContainerName") 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. "ContainerName") 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:"-"`
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              ItemMetadata: Available metadata fields for the item.

                                                                                                                                                                                                                                                                                                                                              func (*ItemMetadata) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                              type ItemStatus

                                                                                                                                                                                                                                                                                                                                              type ItemStatus struct {
                                                                                                                                                                                                                                                                                                                                              	// Code: Status code.
                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                              	// Possible values:
                                                                                                                                                                                                                                                                                                                                              	//   "CODE_UNSPECIFIED" - Input-only value.  Used with
                                                                                                                                                                                                                                                                                                                                              	// Items.list
                                                                                                                                                                                                                                                                                                                                              	// to list all items in the queue, regardless of status.
                                                                                                                                                                                                                                                                                                                                              	//   "ERROR" - Error encountered by Cloud Search while processing this
                                                                                                                                                                                                                                                                                                                                              	// item.
                                                                                                                                                                                                                                                                                                                                              	// Details of the error are in
                                                                                                                                                                                                                                                                                                                                              	// repositoryError.
                                                                                                                                                                                                                                                                                                                                              	//   "MODIFIED" - Item has been modified in the repository, and is out
                                                                                                                                                                                                                                                                                                                                              	// of date with
                                                                                                                                                                                                                                                                                                                                              	// the version previously accepted into Cloud Search.
                                                                                                                                                                                                                                                                                                                                              	//   "NEW_ITEM" - Item is known to exist in the repository, but is not
                                                                                                                                                                                                                                                                                                                                              	// yet accepted by
                                                                                                                                                                                                                                                                                                                                              	// Cloud Search.
                                                                                                                                                                                                                                                                                                                                              	// An item can be in this state when
                                                                                                                                                                                                                                                                                                                                              	// Items.push
                                                                                                                                                                                                                                                                                                                                              	// has been called for
                                                                                                                                                                                                                                                                                                                                              	// an item of this name that did not exist previously.
                                                                                                                                                                                                                                                                                                                                              	//   "ACCEPTED" - API has accepted the up-to-date data of this item.
                                                                                                                                                                                                                                                                                                                                              	Code string `json:"code,omitempty"`
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// ProcessingErrors: Error details in case the item is in ERROR state.
                                                                                                                                                                                                                                                                                                                                              	ProcessingErrors []*ProcessingError `json:"processingErrors,omitempty"`
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// RepositoryErrors: Repository error reported by connector.
                                                                                                                                                                                                                                                                                                                                              	RepositoryErrors []*RepositoryError `json:"repositoryErrors,omitempty"`
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Code") to
                                                                                                                                                                                                                                                                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                              	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                              	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// NullFields is a list of field names (e.g. "Code") to include in API
                                                                                                                                                                                                                                                                                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                ItemStatus: This contains item's status and any errors.

                                                                                                                                                                                                                                                                                                                                                func (*ItemStatus) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                type ItemStructuredData

                                                                                                                                                                                                                                                                                                                                                type ItemStructuredData struct {
                                                                                                                                                                                                                                                                                                                                                	// Hash: Hashing value provided by the API caller.
                                                                                                                                                                                                                                                                                                                                                	// This can be used with the
                                                                                                                                                                                                                                                                                                                                                	// items.push
                                                                                                                                                                                                                                                                                                                                                	// method to calculate modified state.
                                                                                                                                                                                                                                                                                                                                                	// The maximum length is 2048 characters.
                                                                                                                                                                                                                                                                                                                                                	Hash string `json:"hash,omitempty"`
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// Object: The structured data object that should conform to a
                                                                                                                                                                                                                                                                                                                                                	// registered object
                                                                                                                                                                                                                                                                                                                                                	// definition in the schema for the data source.
                                                                                                                                                                                                                                                                                                                                                	Object *StructuredDataObject `json:"object,omitempty"`
                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Hash") 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. "Hash") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  ItemStructuredData: Available structured data fields for the item.

                                                                                                                                                                                                                                                                                                                                                  func (*ItemStructuredData) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                  type ListDataSourceResponse

                                                                                                                                                                                                                                                                                                                                                  type ListDataSourceResponse struct {
                                                                                                                                                                                                                                                                                                                                                  	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                                                                                                                                                                                                                                                                                                  	// if there are no
                                                                                                                                                                                                                                                                                                                                                  	// more results in the list.
                                                                                                                                                                                                                                                                                                                                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	Sources []*DataSource `json:"sources,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                  	// server.
                                                                                                                                                                                                                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                                                                                                                                                                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                                                                                                                                                                                                                                                                                                                  	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                                                                                                                                                  	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                                                                                                                                                  	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                  func (*ListDataSourceResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                  type ListItemNamesForUnmappedIdentityResponse

                                                                                                                                                                                                                                                                                                                                                  type ListItemNamesForUnmappedIdentityResponse struct {
                                                                                                                                                                                                                                                                                                                                                  	ItemNames []string `json:"itemNames,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                                                                                                                                                                                                                                                                                                  	// if there are no
                                                                                                                                                                                                                                                                                                                                                  	// more results in the list.
                                                                                                                                                                                                                                                                                                                                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                  	// server.
                                                                                                                                                                                                                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "ItemNames") 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. "ItemNames") to include in
                                                                                                                                                                                                                                                                                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                  func (*ListItemNamesForUnmappedIdentityResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                  type ListItemsResponse

                                                                                                                                                                                                                                                                                                                                                  type ListItemsResponse struct {
                                                                                                                                                                                                                                                                                                                                                  	Items []*Item `json:"items,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                                                                                                                                                                                                                                                                                                  	// if there are no
                                                                                                                                                                                                                                                                                                                                                  	// more results in the list.
                                                                                                                                                                                                                                                                                                                                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                  	// server.
                                                                                                                                                                                                                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Items") 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. "Items") to include in API
                                                                                                                                                                                                                                                                                                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                  func (*ListItemsResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                  type ListQuerySourcesResponse

                                                                                                                                                                                                                                                                                                                                                  type ListQuerySourcesResponse struct {
                                                                                                                                                                                                                                                                                                                                                  	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	Sources []*QuerySource `json:"sources,omitempty"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                  	// server.
                                                                                                                                                                                                                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                                                                                                                                                                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                                                                                                                                                                                                                                                                                                                  	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                                                                                                                                                  	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                                                                                                                                                  	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    ListQuerySourcesResponse: List sources response.

                                                                                                                                                                                                                                                                                                                                                    func (*ListQuerySourcesResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                    type ListSearchApplicationsResponse

                                                                                                                                                                                                                                                                                                                                                    type ListSearchApplicationsResponse struct {
                                                                                                                                                                                                                                                                                                                                                    	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                                                                                                                                                                                                                                                                                                    	// if there are no
                                                                                                                                                                                                                                                                                                                                                    	// more results in the list.
                                                                                                                                                                                                                                                                                                                                                    	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	SearchApplications []*SearchApplication `json:"searchApplications,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                    	// server.
                                                                                                                                                                                                                                                                                                                                                    	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                                                                                                                                                                                                                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                                                                                                                                                                                                                                                                                                                    	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                                                                                                                                                    	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                                                                                                                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                    func (*ListSearchApplicationsResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                    type ListUnmappedIdentitiesResponse

                                                                                                                                                                                                                                                                                                                                                    type ListUnmappedIdentitiesResponse struct {
                                                                                                                                                                                                                                                                                                                                                    	// NextPageToken: Token to retrieve the next page of results, or empty
                                                                                                                                                                                                                                                                                                                                                    	// if there are no
                                                                                                                                                                                                                                                                                                                                                    	// more results in the list.
                                                                                                                                                                                                                                                                                                                                                    	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	UnmappedIdentities []*UnmappedIdentity `json:"unmappedIdentities,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                    	// server.
                                                                                                                                                                                                                                                                                                                                                    	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                                                                                                                                                                                                                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                                                                                                                                                                                                                                                                                                                    	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                                                                                                                                                    	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                                                                                                                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                    func (*ListUnmappedIdentitiesResponse) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                    type MatchRange

                                                                                                                                                                                                                                                                                                                                                    type MatchRange struct {
                                                                                                                                                                                                                                                                                                                                                    	// End: End of the match in the snippet.
                                                                                                                                                                                                                                                                                                                                                    	End int64 `json:"end,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// Start: Starting position of the match in the snippet.
                                                                                                                                                                                                                                                                                                                                                    	Start int64 `json:"start,omitempty"`
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "End") 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. "End") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      MatchRange: Matched range of a snippet [start, end).

                                                                                                                                                                                                                                                                                                                                                      func (*MatchRange) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                      type Media

                                                                                                                                                                                                                                                                                                                                                      type Media struct {
                                                                                                                                                                                                                                                                                                                                                      	// ResourceName: Name of the media resource.
                                                                                                                                                                                                                                                                                                                                                      	ResourceName string `json:"resourceName,omitempty"`
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                                      	// server.
                                                                                                                                                                                                                                                                                                                                                      	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "ResourceName") 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. "ResourceName") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        Media: Media resource.

                                                                                                                                                                                                                                                                                                                                                        func (*Media) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                        type MediaService

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

                                                                                                                                                                                                                                                                                                                                                        func NewMediaService

                                                                                                                                                                                                                                                                                                                                                        func NewMediaService(s *Service) *MediaService

                                                                                                                                                                                                                                                                                                                                                        func (*MediaService) Upload

                                                                                                                                                                                                                                                                                                                                                        func (r *MediaService) Upload(resourceName string, media *Media) *MediaUploadCall

                                                                                                                                                                                                                                                                                                                                                          Upload: Uploads media for indexing.

                                                                                                                                                                                                                                                                                                                                                          The upload endpoint supports direct and resumable upload protocols and is intended for large items that can not be [inlined during index requests](https://developers.google.com/cloud-search/docs/reference/re st/v1/indexing.datasources.items#itemcontent). To index large content:

                                                                                                                                                                                                                                                                                                                                                          1. Call

                                                                                                                                                                                                                                                                                                                                                          indexing.datasources.items.upload
                                                                                                                                                                                                                                                                                                                                                          with the resource name to begin an upload session and retrieve
                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                          the

                                                                                                                                                                                                                                                                                                                                                          UploadItemRef.
                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                          1. Call media.upload to upload the content using the same resource name from step 1. 1. Call indexing.datasources.items.index

                                                                                                                                                                                                                                                                                                                                                          to index the item. Populate the
                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                          [ItemContent](/cloud-search/docs/reference/rest/v1/indexing.datasource s.items#ItemContent)

                                                                                                                                                                                                                                                                                                                                                          with the UploadItemRef from step 1.
                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                          For additional information, see [Create a content connector using the REST API](https://developers.google.com/cloud-search/docs/guides/content-co nnector#rest).

                                                                                                                                                                                                                                                                                                                                                          **Note:** This API requires a service account to execute.
                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                          type MediaUploadCall

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

                                                                                                                                                                                                                                                                                                                                                          func (*MediaUploadCall) 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. This context will supersede any context previously provided to the ResumableMedia method.

                                                                                                                                                                                                                                                                                                                                                            func (*MediaUploadCall) Do

                                                                                                                                                                                                                                                                                                                                                            func (c *MediaUploadCall) Do(opts ...googleapi.CallOption) (*Media, error)

                                                                                                                                                                                                                                                                                                                                                              Do executes the "cloudsearch.media.upload" call. Exactly one of *Media or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Media.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 (*MediaUploadCall) Fields

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

                                                                                                                                                                                                                                                                                                                                                                func (*MediaUploadCall) Header

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

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

                                                                                                                                                                                                                                                                                                                                                                  func (*MediaUploadCall) Media

                                                                                                                                                                                                                                                                                                                                                                  func (c *MediaUploadCall) Media(r io.Reader, options ...googleapi.MediaOption) *MediaUploadCall

                                                                                                                                                                                                                                                                                                                                                                    Media specifies the media to upload in one or more chunks. The chunk size may be controlled by supplying a MediaOption generated by googleapi.ChunkSize. The chunk size defaults to googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload request will be determined by sniffing the contents of r, unless a MediaOption generated by googleapi.ContentType is supplied. At most one of Media and ResumableMedia may be set.

                                                                                                                                                                                                                                                                                                                                                                    func (*MediaUploadCall) ProgressUpdater

                                                                                                                                                                                                                                                                                                                                                                    func (c *MediaUploadCall) ProgressUpdater(pu googleapi.ProgressUpdater) *MediaUploadCall

                                                                                                                                                                                                                                                                                                                                                                      ProgressUpdater provides a callback function that will be called after every chunk. It should be a low-latency function in order to not slow down the upload operation. This should only be called when using ResumableMedia (as opposed to Media).

                                                                                                                                                                                                                                                                                                                                                                      func (*MediaUploadCall) ResumableMedia

                                                                                                                                                                                                                                                                                                                                                                      func (c *MediaUploadCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *MediaUploadCall

                                                                                                                                                                                                                                                                                                                                                                        ResumableMedia specifies the media to upload in chunks and can be canceled with ctx.

                                                                                                                                                                                                                                                                                                                                                                        Deprecated: use Media instead.

                                                                                                                                                                                                                                                                                                                                                                        At most one of Media and ResumableMedia may be set. mediaType identifies the MIME media type of the upload, such as "image/png". If mediaType is "", it will be auto-detected. The provided ctx will supersede any context previously provided to the Context method.

                                                                                                                                                                                                                                                                                                                                                                        type Metadata

                                                                                                                                                                                                                                                                                                                                                                        type Metadata struct {
                                                                                                                                                                                                                                                                                                                                                                        	// CreateTime: The creation time for this document or object in the
                                                                                                                                                                                                                                                                                                                                                                        	// search result.
                                                                                                                                                                                                                                                                                                                                                                        	CreateTime string `json:"createTime,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// DisplayOptions: Options that specify how to display a structured data
                                                                                                                                                                                                                                                                                                                                                                        	// search result.
                                                                                                                                                                                                                                                                                                                                                                        	DisplayOptions *ResultDisplayMetadata `json:"displayOptions,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// Fields: Indexed fields in structured data, returned as a generic
                                                                                                                                                                                                                                                                                                                                                                        	// named property.
                                                                                                                                                                                                                                                                                                                                                                        	Fields []*NamedProperty `json:"fields,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// MimeType: Mime type of the search result.
                                                                                                                                                                                                                                                                                                                                                                        	MimeType string `json:"mimeType,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// ObjectType: Object type of the search result.
                                                                                                                                                                                                                                                                                                                                                                        	ObjectType string `json:"objectType,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// Owner: Owner (usually creator) of the document or object of the
                                                                                                                                                                                                                                                                                                                                                                        	// search result.
                                                                                                                                                                                                                                                                                                                                                                        	Owner *Person `json:"owner,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// Source: The named source for the result, such as Gmail.
                                                                                                                                                                                                                                                                                                                                                                        	Source *Source `json:"source,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// UpdateTime: The last modified date for the object in the search
                                                                                                                                                                                                                                                                                                                                                                        	// result. If not
                                                                                                                                                                                                                                                                                                                                                                        	// set in the item, the value returned here is empty. When
                                                                                                                                                                                                                                                                                                                                                                        	// `updateTime` is used for calculating freshness and is not set,
                                                                                                                                                                                                                                                                                                                                                                        	// this
                                                                                                                                                                                                                                                                                                                                                                        	// value defaults to 2 years from the current time.
                                                                                                                                                                                                                                                                                                                                                                        	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:"-"`
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          Metadata: Metadata of a matched search result.

                                                                                                                                                                                                                                                                                                                                                                          func (*Metadata) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                          type Metaline

                                                                                                                                                                                                                                                                                                                                                                          type Metaline struct {
                                                                                                                                                                                                                                                                                                                                                                          	// Properties: The list of displayed properties for the metaline. The
                                                                                                                                                                                                                                                                                                                                                                          	// maximum number of
                                                                                                                                                                                                                                                                                                                                                                          	// properties is 5.
                                                                                                                                                                                                                                                                                                                                                                          	Properties []*DisplayedProperty `json:"properties,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Properties") 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. "Properties") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Metaline: A metaline is a list of properties that are displayed along with the search result to provide context.

                                                                                                                                                                                                                                                                                                                                                                            func (*Metaline) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                            type Name

                                                                                                                                                                                                                                                                                                                                                                            type Name struct {
                                                                                                                                                                                                                                                                                                                                                                            	// DisplayName: The read-only display name formatted according to the
                                                                                                                                                                                                                                                                                                                                                                            	// locale specified by
                                                                                                                                                                                                                                                                                                                                                                            	// the viewer's account or the <code>Accept-Language</code> HTTP header.
                                                                                                                                                                                                                                                                                                                                                                            	DisplayName string `json:"displayName,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "DisplayName") to
                                                                                                                                                                                                                                                                                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// NullFields is a list of field names (e.g. "DisplayName") to include
                                                                                                                                                                                                                                                                                                                                                                            	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                                                                                                                                                                            	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                                                                                                                                                                            	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                                                                                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                                                                                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              Name: A person's name.

                                                                                                                                                                                                                                                                                                                                                                              func (*Name) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                              type NamedProperty

                                                                                                                                                                                                                                                                                                                                                                              type NamedProperty struct {
                                                                                                                                                                                                                                                                                                                                                                              	BooleanValue bool `json:"booleanValue,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	DateValues *DateValues `json:"dateValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	DoubleValues *DoubleValues `json:"doubleValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	EnumValues *EnumValues `json:"enumValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	HtmlValues *HtmlValues `json:"htmlValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	IntegerValues *IntegerValues `json:"integerValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// Name: The name of the property.  This name should correspond to the
                                                                                                                                                                                                                                                                                                                                                                              	// name of the
                                                                                                                                                                                                                                                                                                                                                                              	// property that was registered for object definition in the schema.
                                                                                                                                                                                                                                                                                                                                                                              	// The maximum allowable length for this property is 256 characters.
                                                                                                                                                                                                                                                                                                                                                                              	Name string `json:"name,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	ObjectValues *ObjectValues `json:"objectValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	TextValues *TextValues `json:"textValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	TimestampValues *TimestampValues `json:"timestampValues,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "BooleanValue") 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. "BooleanValue") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                NamedProperty: A typed name-value pair for structured data. The type of the value should be the same as the registered type for the `name` property in the object definition of `objectType`.

                                                                                                                                                                                                                                                                                                                                                                                func (*NamedProperty) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                type ObjectDefinition

                                                                                                                                                                                                                                                                                                                                                                                type ObjectDefinition struct {
                                                                                                                                                                                                                                                                                                                                                                                	// Name: Name for the object, which then defines its type. Item indexing
                                                                                                                                                                                                                                                                                                                                                                                	// requests
                                                                                                                                                                                                                                                                                                                                                                                	// should set the
                                                                                                                                                                                                                                                                                                                                                                                	// objectType field
                                                                                                                                                                                                                                                                                                                                                                                	// equal to this value. For example, if *name* is *Document*, then
                                                                                                                                                                                                                                                                                                                                                                                	// indexing
                                                                                                                                                                                                                                                                                                                                                                                	// requests for items of type Document should set
                                                                                                                                                                                                                                                                                                                                                                                	// objectType equal to
                                                                                                                                                                                                                                                                                                                                                                                	// *Document*. Each object definition must be uniquely named within a
                                                                                                                                                                                                                                                                                                                                                                                	// schema.
                                                                                                                                                                                                                                                                                                                                                                                	// The name must start with a letter and can only contain letters (A-Z,
                                                                                                                                                                                                                                                                                                                                                                                	// a-z)
                                                                                                                                                                                                                                                                                                                                                                                	// or numbers (0-9).
                                                                                                                                                                                                                                                                                                                                                                                	// The maximum length is 256 characters.
                                                                                                                                                                                                                                                                                                                                                                                	Name string `json:"name,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Options: The optional object-specific options.
                                                                                                                                                                                                                                                                                                                                                                                	Options *ObjectOptions `json:"options,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// PropertyDefinitions: The property definitions for the object.
                                                                                                                                                                                                                                                                                                                                                                                	// The maximum number of elements is 1000.
                                                                                                                                                                                                                                                                                                                                                                                	PropertyDefinitions []*PropertyDefinition `json:"propertyDefinitions,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Name") 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. "Name") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  ObjectDefinition: The definition for an object within a data source.

                                                                                                                                                                                                                                                                                                                                                                                  func (*ObjectDefinition) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                  type ObjectDisplayOptions

                                                                                                                                                                                                                                                                                                                                                                                  type ObjectDisplayOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                  	// Metalines: Defines the properties that are displayed in the metalines
                                                                                                                                                                                                                                                                                                                                                                                  	// of the
                                                                                                                                                                                                                                                                                                                                                                                  	// search results. The property values are displayed in the order
                                                                                                                                                                                                                                                                                                                                                                                  	// given
                                                                                                                                                                                                                                                                                                                                                                                  	// here. If a property holds multiple values, all of the values
                                                                                                                                                                                                                                                                                                                                                                                  	// are
                                                                                                                                                                                                                                                                                                                                                                                  	// displayed before the next properties. For this reason, it is a
                                                                                                                                                                                                                                                                                                                                                                                  	// good
                                                                                                                                                                                                                                                                                                                                                                                  	// practice to specify singular properties before repeated properties in
                                                                                                                                                                                                                                                                                                                                                                                  	// this
                                                                                                                                                                                                                                                                                                                                                                                  	// list. All of the properties must set
                                                                                                                                                                                                                                                                                                                                                                                  	// is_returnable
                                                                                                                                                                                                                                                                                                                                                                                  	// to true. The maximum number of metalines is 3.
                                                                                                                                                                                                                                                                                                                                                                                  	Metalines []*Metaline `json:"metalines,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// ObjectDisplayLabel: The user friendly label to display in the search
                                                                                                                                                                                                                                                                                                                                                                                  	// result to indicate the
                                                                                                                                                                                                                                                                                                                                                                                  	// type of the item. This is OPTIONAL; if not provided, an object label
                                                                                                                                                                                                                                                                                                                                                                                  	// isn't
                                                                                                                                                                                                                                                                                                                                                                                  	// displayed on the context line of the search results. The maximum
                                                                                                                                                                                                                                                                                                                                                                                  	// length
                                                                                                                                                                                                                                                                                                                                                                                  	// is 64 characters.
                                                                                                                                                                                                                                                                                                                                                                                  	ObjectDisplayLabel string `json:"objectDisplayLabel,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Metalines") 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. "Metalines") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    ObjectDisplayOptions: The display options for an object.

                                                                                                                                                                                                                                                                                                                                                                                    func (*ObjectDisplayOptions) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                    type ObjectOptions

                                                                                                                                                                                                                                                                                                                                                                                    type ObjectOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                    	// DisplayOptions: Options that determine how the object is displayed in
                                                                                                                                                                                                                                                                                                                                                                                    	// the Cloud Search
                                                                                                                                                                                                                                                                                                                                                                                    	// results page.
                                                                                                                                                                                                                                                                                                                                                                                    	DisplayOptions *ObjectDisplayOptions `json:"displayOptions,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// FreshnessOptions: The freshness options for an object.
                                                                                                                                                                                                                                                                                                                                                                                    	FreshnessOptions *FreshnessOptions `json:"freshnessOptions,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "DisplayOptions") 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. "DisplayOptions") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      ObjectOptions: The options for an object.

                                                                                                                                                                                                                                                                                                                                                                                      func (*ObjectOptions) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                      type ObjectPropertyOptions

                                                                                                                                                                                                                                                                                                                                                                                      type ObjectPropertyOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                      	// SubobjectProperties: The properties of the sub-object. These
                                                                                                                                                                                                                                                                                                                                                                                      	// properties represent a nested
                                                                                                                                                                                                                                                                                                                                                                                      	// object. For example, if this property represents a postal address,
                                                                                                                                                                                                                                                                                                                                                                                      	// the
                                                                                                                                                                                                                                                                                                                                                                                      	// subobjectProperties might be named *street*, *city*, and *state*.
                                                                                                                                                                                                                                                                                                                                                                                      	// The maximum number of elements is 1000.
                                                                                                                                                                                                                                                                                                                                                                                      	SubobjectProperties []*PropertyDefinition `json:"subobjectProperties,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "SubobjectProperties")
                                                                                                                                                                                                                                                                                                                                                                                      	// 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. "SubobjectProperties") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        ObjectPropertyOptions: Options for object properties.

                                                                                                                                                                                                                                                                                                                                                                                        func (*ObjectPropertyOptions) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                        type ObjectValues

                                                                                                                                                                                                                                                                                                                                                                                        type ObjectValues struct {
                                                                                                                                                                                                                                                                                                                                                                                        	Values []*StructuredDataObject `json:"values,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Values") 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. "Values") 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:"-"`
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          ObjectValues: List of object values.

                                                                                                                                                                                                                                                                                                                                                                                          func (*ObjectValues) MarshalJSON

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

                                                                                                                                                                                                                                                                                                                                                                                          type Operation

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