Documentation

Overview

Package playablelocations provides access to the Playable Locations API.

For product documentation, see: https://developers.google.com/maps/contact-sales/

Creating a client

Usage example:

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

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

playablelocationsService, err := playablelocations.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, ...)
playablelocationsService, err := playablelocations.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

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

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GoogleMapsPlayablelocationsV3Impression

type GoogleMapsPlayablelocationsV3Impression struct {
	// GameObjectType: An arbitrary, developer-defined type identifier for
	// each type of game object used in your game. Since players interact
	// with differ types of game objects in different ways, this field
	// allows you to segregate impression data by type for analysis. You
	// should assign a unique `game_object_type` ID to represent a distinct
	// type of game object in your game. For example, 1=monster location,
	// 2=powerup location.
	GameObjectType int64 `json:"gameObjectType,omitempty"`

	// ImpressionType: Required. The type of impression event.
	//
	// Possible values:
	//   "IMPRESSION_TYPE_UNSPECIFIED" - Unspecified type. Do not use.
	//   "PRESENTED" - The playable location was presented to a player.
	//   "INTERACTED" - A player interacted with the playable location.
	ImpressionType string `json:"impressionType,omitempty"`

	// LocationName: Required. The name of the playable location.
	LocationName string `json:"locationName,omitempty"`

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

    GoogleMapsPlayablelocationsV3Impression: Encapsulates impression event details.

    func (*GoogleMapsPlayablelocationsV3Impression) MarshalJSON

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

    type GoogleMapsPlayablelocationsV3LogImpressionsRequest

    type GoogleMapsPlayablelocationsV3LogImpressionsRequest struct {
    	// ClientInfo: Required. Information about the client device. For
    	// example, device model and operating system.
    	ClientInfo *GoogleMapsUnityClientInfo `json:"clientInfo,omitempty"`
    
    	// Impressions: Required. Impression event details. The maximum number
    	// of impression reports that you can log at once is 50.
    	Impressions []*GoogleMapsPlayablelocationsV3Impression `json:"impressions,omitempty"`
    
    	// RequestId: Required. A string that uniquely identifies the log
    	// impressions request. This allows you to detect duplicate requests. We
    	// recommend that you use UUIDs for this value. The value must not
    	// exceed 50 characters. You should reuse the `request_id` only when
    	// retrying a request in case of failure. In this case, the request must
    	// be identical to the one that failed.
    	RequestId string `json:"requestId,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "ClientInfo") 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. "ClientInfo") 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:"-"`
    }

      GoogleMapsPlayablelocationsV3LogImpressionsRequest: A request for logging impressions.

      func (*GoogleMapsPlayablelocationsV3LogImpressionsRequest) MarshalJSON

      type GoogleMapsPlayablelocationsV3LogImpressionsResponse

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

        GoogleMapsPlayablelocationsV3LogImpressionsResponse: A response for the LogImpressions method. This method returns no data upon success.

        type GoogleMapsPlayablelocationsV3LogPlayerReportsRequest

        type GoogleMapsPlayablelocationsV3LogPlayerReportsRequest struct {
        	// ClientInfo: Required. Information about the client device (for
        	// example, device model and operating system).
        	ClientInfo *GoogleMapsUnityClientInfo `json:"clientInfo,omitempty"`
        
        	// PlayerReports: Required. Player reports. The maximum number of player
        	// reports that you can log at once is 50.
        	PlayerReports []*GoogleMapsPlayablelocationsV3PlayerReport `json:"playerReports,omitempty"`
        
        	// RequestId: Required. A string that uniquely identifies the log player
        	// reports request. This allows you to detect duplicate requests. We
        	// recommend that you use UUIDs for this value. The value must not
        	// exceed 50 characters. You should reuse the `request_id` only when
        	// retrying a request in the case of a failure. In that case, the
        	// request must be identical to the one that failed.
        	RequestId string `json:"requestId,omitempty"`
        
        	// ForceSendFields is a list of field names (e.g. "ClientInfo") 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. "ClientInfo") 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:"-"`
        }

          GoogleMapsPlayablelocationsV3LogPlayerReportsRequest: A request for logging your player's bad location reports.

          func (*GoogleMapsPlayablelocationsV3LogPlayerReportsRequest) MarshalJSON

          type GoogleMapsPlayablelocationsV3LogPlayerReportsResponse

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

            GoogleMapsPlayablelocationsV3LogPlayerReportsResponse: A response for the LogPlayerReports method. This method returns no data upon success.

            type GoogleMapsPlayablelocationsV3PlayerReport

            type GoogleMapsPlayablelocationsV3PlayerReport struct {
            	// LanguageCode: Language code (in BCP-47 format) indicating the
            	// language of the freeform description provided in `reason_details`.
            	// Examples are "en", "en-US" or "ja-Latn". For more information, see
            	// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
            	LanguageCode string `json:"languageCode,omitempty"`
            
            	// LocationName: Required. The name of the playable location.
            	LocationName string `json:"locationName,omitempty"`
            
            	// ReasonDetails: Required. A free-form description detailing why the
            	// playable location is considered bad.
            	ReasonDetails string `json:"reasonDetails,omitempty"`
            
            	// Reasons: Required. One or more reasons why this playable location is
            	// considered bad.
            	//
            	// Possible values:
            	//   "BAD_LOCATION_REASON_UNSPECIFIED" - Unspecified reason. Do not use.
            	//   "OTHER" - The reason isn't one of the reasons in this enumeration.
            	//   "NOT_PEDESTRIAN_ACCESSIBLE" - The playable location isn't
            	// accessible to pedestrians. For example, if it's in the middle of a
            	// highway.
            	//   "NOT_OPEN_TO_PUBLIC" - The playable location isn't open to the
            	// public. For example, a private office building.
            	//   "PERMANENTLY_CLOSED" - The playable location is permanently closed.
            	// For example, when a business has been shut down.
            	//   "TEMPORARILY_INACCESSIBLE" - The playable location is temporarily
            	// inaccessible. For example, when a business has closed for
            	// renovations.
            	Reasons []string `json:"reasons,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "LanguageCode") 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. "LanguageCode") 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:"-"`
            }

              GoogleMapsPlayablelocationsV3PlayerReport: A report submitted by a player about a playable location that is considered inappropriate for use in the game.

              func (*GoogleMapsPlayablelocationsV3PlayerReport) MarshalJSON

              type GoogleMapsPlayablelocationsV3SampleAreaFilter

              type GoogleMapsPlayablelocationsV3SampleAreaFilter struct {
              	// S2CellId: Required. The S2 cell ID of the area you want. This must be
              	// between cell level 11 and 14 (inclusive). S2 cells are 64-bit
              	// integers that identify areas on the Earth. They are hierarchical, and
              	// can therefore be used for spatial indexing. The S2 geometry library
              	// is available in a number of languages: * C++
              	// (https://github.com/google/s2geometry) * Java
              	// (https://github.com/google/s2-geometry-library-java) * Go
              	// (https://github.com/golang/geo) * Python
              	// (https://github.com/google/s2geometry/tree/master/src/python)
              	S2CellId uint64 `json:"s2CellId,omitempty,string"`
              
              	// ForceSendFields is a list of field names (e.g. "S2CellId") 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. "S2CellId") 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:"-"`
              }

                GoogleMapsPlayablelocationsV3SampleAreaFilter: Specifies the area to search for playable locations.

                func (*GoogleMapsPlayablelocationsV3SampleAreaFilter) MarshalJSON

                type GoogleMapsPlayablelocationsV3SampleCriterion

                type GoogleMapsPlayablelocationsV3SampleCriterion struct {
                	// FieldsToReturn: Specifies which `PlayableLocation` fields are
                	// returned. `name` (which is used for logging impressions),
                	// `center_point` and `place_id` (or `plus_code`) are always returned.
                	// The following fields are omitted unless you specify them here: *
                	// snapped_point * types Note: The more fields you include, the more
                	// expensive in terms of data and associated latency your query will be.
                	FieldsToReturn string `json:"fieldsToReturn,omitempty"`
                
                	// Filter: Specifies filtering options, and specifies what will be
                	// included in the result set.
                	Filter *GoogleMapsPlayablelocationsV3SampleFilter `json:"filter,omitempty"`
                
                	// GameObjectType: Required. An arbitrary, developer-defined identifier
                	// of the type of game object that the playable location is used for.
                	// This field allows you to specify criteria per game object type when
                	// searching for playable locations. You should assign a unique
                	// `game_object_type` ID across all `request_criteria` to represent a
                	// distinct type of game object. For example, 1=monster location,
                	// 2=powerup location. The response contains a map.
                	GameObjectType int64 `json:"gameObjectType,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "FieldsToReturn") 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. "FieldsToReturn") 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:"-"`
                }

                  GoogleMapsPlayablelocationsV3SampleCriterion: Encapsulates a filter criterion for searching for a set of playable locations.

                  func (*GoogleMapsPlayablelocationsV3SampleCriterion) MarshalJSON

                  type GoogleMapsPlayablelocationsV3SampleFilter

                  type GoogleMapsPlayablelocationsV3SampleFilter struct {
                  	// IncludedTypes: Restricts the set of playable locations to just the
                  	// types (/maps/documentation/gaming/tt/types) that you want.
                  	IncludedTypes []string `json:"includedTypes,omitempty"`
                  
                  	// MaxLocationCount: Specifies the maximum number of playable locations
                  	// to return. This value must not be greater than 1000. The default
                  	// value is 100. Only the top-ranking playable locations are returned.
                  	MaxLocationCount int64 `json:"maxLocationCount,omitempty"`
                  
                  	// Spacing: A set of options that control the spacing between playable
                  	// locations. By default the minimum distance between locations is 200m.
                  	Spacing *GoogleMapsPlayablelocationsV3SampleSpacingOptions `json:"spacing,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "IncludedTypes") 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. "IncludedTypes") 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:"-"`
                  }

                    GoogleMapsPlayablelocationsV3SampleFilter: Specifies the filters to use when searching for playable locations.

                    func (*GoogleMapsPlayablelocationsV3SampleFilter) MarshalJSON

                    type GoogleMapsPlayablelocationsV3SamplePlayableLocation

                    type GoogleMapsPlayablelocationsV3SamplePlayableLocation struct {
                    	// CenterPoint: Required. The latitude and longitude associated with the
                    	// center of the playable location. By default, the set of playable
                    	// locations returned from SamplePlayableLocations use center-point
                    	// coordinates.
                    	CenterPoint *GoogleTypeLatLng `json:"centerPoint,omitempty"`
                    
                    	// Name: Required. The name of this playable location.
                    	Name string `json:"name,omitempty"`
                    
                    	// PlaceId: A [place ID] (https://developers.google.com/places/place-id)
                    	PlaceId string `json:"placeId,omitempty"`
                    
                    	// PlusCode: A [plus code] (http://openlocationcode.com)
                    	PlusCode string `json:"plusCode,omitempty"`
                    
                    	// SnappedPoint: The playable location's coordinates, snapped to the
                    	// sidewalk of the nearest road, if a nearby road exists.
                    	SnappedPoint *GoogleTypeLatLng `json:"snappedPoint,omitempty"`
                    
                    	// Types: A collection of Playable Location Types
                    	// (/maps/documentation/gaming/tt/types) for this playable location. The
                    	// first type in the collection is the primary type. Type information
                    	// might not be available for all playable locations.
                    	Types []string `json:"types,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "CenterPoint") 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. "CenterPoint") 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:"-"`
                    }

                      GoogleMapsPlayablelocationsV3SamplePlayableLocation: A geographical point suitable for placing game objects in location-based games.

                      func (*GoogleMapsPlayablelocationsV3SamplePlayableLocation) MarshalJSON

                      type GoogleMapsPlayablelocationsV3SamplePlayableLocationList

                      type GoogleMapsPlayablelocationsV3SamplePlayableLocationList struct {
                      	// Locations: A list of playable locations for this game object type.
                      	Locations []*GoogleMapsPlayablelocationsV3SamplePlayableLocation `json:"locations,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "Locations") to
                      	// unconditionally include in API requests. By default, fields with
                      	// empty values are omitted from API requests. However, any non-pointer,
                      	// non-interface field appearing in ForceSendFields will be sent to the
                      	// server regardless of whether the field is empty or not. This may be
                      	// used to include empty fields in Patch requests.
                      	ForceSendFields []string `json:"-"`
                      
                      	// NullFields is a list of field names (e.g. "Locations") to include in
                      	// API requests with the JSON null value. By default, fields with empty
                      	// values are omitted from API requests. However, any field with an
                      	// empty value appearing in NullFields will be sent to the server as
                      	// null. It is an error if a field in this list has a non-empty value.
                      	// This may be used to include null fields in Patch requests.
                      	NullFields []string `json:"-"`
                      }

                        GoogleMapsPlayablelocationsV3SamplePlayableLocationList: A list of PlayableLocation objects that satisfies a single Criterion.

                        func (*GoogleMapsPlayablelocationsV3SamplePlayableLocationList) MarshalJSON

                        type GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest

                        type GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest struct {
                        	// AreaFilter: Required. Specifies the area to search within for
                        	// playable locations.
                        	AreaFilter *GoogleMapsPlayablelocationsV3SampleAreaFilter `json:"areaFilter,omitempty"`
                        
                        	// Criteria: Required. Specifies one or more (up to 5) criteria for
                        	// filtering the returned playable locations.
                        	Criteria []*GoogleMapsPlayablelocationsV3SampleCriterion `json:"criteria,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "AreaFilter") 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. "AreaFilter") 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:"-"`
                        }

                          GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest: Life of a query: - When a game starts in a new location, your game server issues a SamplePlayableLocations request. The request specifies the S2 cell, and contains one or more "criteria" for filtering: - Criterion 0: i locations for long-lived bases, or level 0 monsters, or... - Criterion 1: j locations for short-lived bases, or level 1 monsters, ... - Criterion 2: k locations for random objects. - etc (up to 5 criterion may be specified). `PlayableLocationList` will then contain mutually exclusive lists of `PlayableLocation` objects that satisfy each of the criteria. Think of it as a collection of real-world locations that you can then associate with your game state. Note: These points are impermanent in nature. E.g, parks can close, and places can be removed. The response specifies how long you can expect the playable locations to last. Once they expire, you should query the `samplePlayableLocations` API again to get a fresh view of the real world.

                          func (*GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest) MarshalJSON

                          type GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse

                          type GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse struct {
                          	// LocationsPerGameObjectType: Each PlayableLocation object corresponds
                          	// to a game_object_type specified in the request.
                          	LocationsPerGameObjectType map[string]GoogleMapsPlayablelocationsV3SamplePlayableLocationList `json:"locationsPerGameObjectType,omitempty"`
                          
                          	// Ttl: Required. Specifies the "time-to-live" for the set of playable
                          	// locations. You can use this value to determine how long to cache the
                          	// set of playable locations. After this length of time, your back-end
                          	// game server should issue a new SamplePlayableLocations request to get
                          	// a fresh set of playable locations (because for example, they might
                          	// have been removed, a park might have closed for the day, a business
                          	// might have closed permanently).
                          	Ttl string `json:"ttl,omitempty"`
                          
                          	// ServerResponse contains the HTTP response code and headers from the
                          	// server.
                          	googleapi.ServerResponse `json:"-"`
                          
                          	// ForceSendFields is a list of field names (e.g.
                          	// "LocationsPerGameObjectType") 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.
                          	// "LocationsPerGameObjectType") 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:"-"`
                          }

                            GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse: Response for the SamplePlayableLocations method.

                            func (*GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse) MarshalJSON

                            type GoogleMapsPlayablelocationsV3SampleSpacingOptions

                            type GoogleMapsPlayablelocationsV3SampleSpacingOptions struct {
                            	// MinSpacingMeters: Required. The minimum spacing between any two
                            	// playable locations, measured in meters. The minimum value is 30. The
                            	// maximum value is 1000. Inputs will be rounded up to the next 10 meter
                            	// interval. The default value is 200m. Set this field to remove tight
                            	// clusters of playable locations. Note: The spacing is a greedy
                            	// algorithm. It optimizes for selecting the highest ranking locations
                            	// first, not to maximize the number of locations selected. Consider the
                            	// following scenario: * Rank: A: 2, B: 1, C: 3. * Distance:
                            	// A--200m--B--200m--C If spacing=250, it will pick the highest ranked
                            	// location [B], not [A, C]. Note: Spacing works within the game object
                            	// type itself, as well as the previous ones. Suppose three game object
                            	// types, each with the following spacing: * X: 400m, Y: undefined, Z:
                            	// 200m. 1. Add locations for X, within 400m of each other. 2. Add
                            	// locations for Y, without any spacing. 3. Finally, add locations for Z
                            	// within 200m of each other as well X and Y. The distance diagram
                            	// between those locations end up as: * From->To. * X->X: 400m * Y->X,
                            	// Y->Y: unspecified. * Z->X, Z->Y, Z->Z: 200m.
                            	MinSpacingMeters float64 `json:"minSpacingMeters,omitempty"`
                            
                            	// PointType: Specifies whether the minimum spacing constraint applies
                            	// to the center-point or to the snapped point of playable locations.
                            	// The default value is `CENTER_POINT`. If a snapped point is not
                            	// available for a playable location, its center-point is used instead.
                            	// Set this to the point type used in your game.
                            	//
                            	// Possible values:
                            	//   "POINT_TYPE_UNSPECIFIED" - Unspecified point type. Do not use this
                            	// value.
                            	//   "CENTER_POINT" - The geographic coordinates correspond to the
                            	// center of the location.
                            	//   "SNAPPED_POINT" - The geographic coordinates correspond to the
                            	// location snapped to the sidewalk of the nearest road (when a nearby
                            	// road exists).
                            	PointType string `json:"pointType,omitempty"`
                            
                            	// ForceSendFields is a list of field names (e.g. "MinSpacingMeters") 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. "MinSpacingMeters") 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:"-"`
                            }

                              GoogleMapsPlayablelocationsV3SampleSpacingOptions: A set of options that specifies the separation between playable locations.

                              func (*GoogleMapsPlayablelocationsV3SampleSpacingOptions) MarshalJSON

                              func (*GoogleMapsPlayablelocationsV3SampleSpacingOptions) UnmarshalJSON

                              type GoogleMapsUnityClientInfo

                              type GoogleMapsUnityClientInfo struct {
                              	// ApiClient: API client name and version. For example, the SDK calling
                              	// the API. The exact format is up to the client.
                              	ApiClient string `json:"apiClient,omitempty"`
                              
                              	// ApplicationId: Application ID, such as the package name on Android
                              	// and the bundle identifier on iOS platforms.
                              	ApplicationId string `json:"applicationId,omitempty"`
                              
                              	// ApplicationVersion: Application version number, such as "1.2.3". The
                              	// exact format is application-dependent.
                              	ApplicationVersion string `json:"applicationVersion,omitempty"`
                              
                              	// DeviceModel: Device model as reported by the device. The exact format
                              	// is platform-dependent.
                              	DeviceModel string `json:"deviceModel,omitempty"`
                              
                              	// LanguageCode: Language code (in BCP-47 format) indicating the UI
                              	// language of the client. Examples are "en", "en-US" or "ja-Latn". For
                              	// more information, see
                              	// http://www.unicode.org/reports/tr35/#Unicode_locale_identifier.
                              	LanguageCode string `json:"languageCode,omitempty"`
                              
                              	// OperatingSystem: Operating system name and version as reported by the
                              	// OS. For example, "Mac OS X 10.10.4". The exact format is
                              	// platform-dependent.
                              	OperatingSystem string `json:"operatingSystem,omitempty"`
                              
                              	// OperatingSystemBuild: Build number/version of the operating system.
                              	// e.g., the contents of android.os.Build.ID in Android, or the contents
                              	// of sysctl "kern.osversion" in iOS.
                              	OperatingSystemBuild string `json:"operatingSystemBuild,omitempty"`
                              
                              	// Platform: Platform where the application is running.
                              	//
                              	// Possible values:
                              	//   "PLATFORM_UNSPECIFIED" - Unspecified or unknown OS.
                              	//   "EDITOR" - Development environment.
                              	//   "MAC_OS" - macOS.
                              	//   "WINDOWS" - Windows.
                              	//   "LINUX" - Linux
                              	//   "ANDROID" - Android
                              	//   "IOS" - iOS
                              	//   "WEB_GL" - WebGL.
                              	Platform string `json:"platform,omitempty"`
                              
                              	// ForceSendFields is a list of field names (e.g. "ApiClient") 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. "ApiClient") 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:"-"`
                              }

                                GoogleMapsUnityClientInfo: Client information.

                                func (*GoogleMapsUnityClientInfo) MarshalJSON

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

                                type GoogleTypeLatLng

                                type GoogleTypeLatLng struct {
                                	// Latitude: The latitude in degrees. It must be in the range [-90.0,
                                	// +90.0].
                                	Latitude float64 `json:"latitude,omitempty"`
                                
                                	// Longitude: The longitude in degrees. It must be in the range [-180.0,
                                	// +180.0].
                                	Longitude float64 `json:"longitude,omitempty"`
                                
                                	// ForceSendFields is a list of field names (e.g. "Latitude") 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. "Latitude") 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:"-"`
                                }

                                  GoogleTypeLatLng: An object that represents a latitude/longitude pair. This is expressed as a pair of doubles to represent degrees latitude and degrees longitude. Unless specified otherwise, this must conform to the WGS84 standard. Values must be within normalized ranges.

                                  func (*GoogleTypeLatLng) MarshalJSON

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

                                  func (*GoogleTypeLatLng) UnmarshalJSON

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

                                  type Service

                                  type Service struct {
                                  	BasePath  string // API endpoint base URL
                                  	UserAgent string // optional additional User-Agent fragment
                                  
                                  	V3 *V3Service
                                  	// contains filtered or unexported fields
                                  }

                                  func New

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

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

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

                                    func NewService

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

                                      NewService creates a new Service.

                                      type V3LogImpressionsCall

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

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

                                          Do executes the "playablelocations.logImpressions" call. Exactly one of *GoogleMapsPlayablelocationsV3LogImpressionsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *GoogleMapsPlayablelocationsV3LogImpressionsResponse.ServerResponse.He ader 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 (*V3LogImpressionsCall) Fields

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

                                            func (*V3LogImpressionsCall) Header

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

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

                                              type V3LogPlayerReportsCall

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

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

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

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

                                                    func (*V3LogPlayerReportsCall) Header

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

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

                                                      type V3SamplePlayableLocationsCall

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

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

                                                          Do executes the "playablelocations.samplePlayableLocations" call. Exactly one of *GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *GoogleMapsPlayablelocationsV3SamplePlayableLocationsResponse.ServerRe sponse.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 (*V3SamplePlayableLocationsCall) Fields

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

                                                            func (*V3SamplePlayableLocationsCall) Header

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

                                                              type V3Service

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

                                                              func NewV3Service

                                                              func NewV3Service(s *Service) *V3Service

                                                              func (*V3Service) LogImpressions

                                                              func (r *V3Service) LogImpressions(googlemapsplayablelocationsv3logimpressionsrequest *GoogleMapsPlayablelocationsV3LogImpressionsRequest) *V3LogImpressionsCall

                                                                LogImpressions: Logs new events when playable locations are displayed, and when they are interacted with. Impressions are not partially saved; either all impressions are saved and this request succeeds, or no impressions are saved, and this request fails.

                                                                func (*V3Service) LogPlayerReports

                                                                func (r *V3Service) LogPlayerReports(googlemapsplayablelocationsv3logplayerreportsrequest *GoogleMapsPlayablelocationsV3LogPlayerReportsRequest) *V3LogPlayerReportsCall

                                                                  LogPlayerReports: Logs bad playable location reports submitted by players. Reports are not partially saved; either all reports are saved and this request succeeds, or no reports are saved, and this request fails.

                                                                  func (*V3Service) SamplePlayableLocations

                                                                  func (r *V3Service) SamplePlayableLocations(googlemapsplayablelocationsv3sampleplayablelocationsrequest *GoogleMapsPlayablelocationsV3SamplePlayableLocationsRequest) *V3SamplePlayableLocationsCall

                                                                    SamplePlayableLocations: Returns a set of playable locations that lie within a specified area, that satisfy optional filter criteria. Note: Identical `SamplePlayableLocations` requests can return different results as the state of the world changes over time.