Documentation

Overview

Package gamesmanagement provides access to the Google Play Game Services Management API.

For product documentation, see: https://developers.google.com/games/services

Creating a client

Usage example:

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

gamesmanagementService, err := gamesmanagement.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, ...)
gamesmanagementService, err := gamesmanagement.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 (
	// Create, edit, and delete your Google Play Games activity
	GamesScope = "https://www.googleapis.com/auth/games"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AchievementResetAllResponse

    type AchievementResetAllResponse struct {
    	// Kind: Uniquely identifies the type of this resource. Value is always
    	// the fixed string gamesManagement#achievementResetAllResponse.
    	Kind string `json:"kind,omitempty"`
    
    	// Results: The achievement reset results.
    	Results []*AchievementResetResponse `json:"results,omitempty"`
    
    	// ServerResponse contains the HTTP response code and headers from the
    	// server.
    	googleapi.ServerResponse `json:"-"`
    
    	// ForceSendFields is a list of field names (e.g. "Kind") 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. "Kind") 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:"-"`
    }

      AchievementResetAllResponse: This is a JSON template for achievement reset all response.

      func (*AchievementResetAllResponse) MarshalJSON

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

      type AchievementResetMultipleForAllRequest

      type AchievementResetMultipleForAllRequest struct {
      	// AchievementIds: The IDs of achievements to reset.
      	AchievementIds []string `json:"achievement_ids,omitempty"`
      
      	// Kind: Uniquely identifies the type of this resource. Value is always
      	// the fixed string
      	// gamesManagement#achievementResetMultipleForAllRequest.
      	Kind string `json:"kind,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g. "AchievementIds") 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. "AchievementIds") 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:"-"`
      }

        AchievementResetMultipleForAllRequest: This is a JSON template for multiple achievements reset all request.

        func (*AchievementResetMultipleForAllRequest) MarshalJSON

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

        type AchievementResetResponse

        type AchievementResetResponse struct {
        	// CurrentState: The current state of the achievement. This is the same
        	// as the initial state of the achievement.
        	// Possible values are:
        	// - "HIDDEN"- Achievement is hidden.
        	// - "REVEALED" - Achievement is revealed.
        	// - "UNLOCKED" - Achievement is unlocked.
        	CurrentState string `json:"currentState,omitempty"`
        
        	// DefinitionId: The ID of an achievement for which player state has
        	// been updated.
        	DefinitionId string `json:"definitionId,omitempty"`
        
        	// Kind: Uniquely identifies the type of this resource. Value is always
        	// the fixed string gamesManagement#achievementResetResponse.
        	Kind string `json:"kind,omitempty"`
        
        	// UpdateOccurred: Flag to indicate if the requested update actually
        	// occurred.
        	UpdateOccurred bool `json:"updateOccurred,omitempty"`
        
        	// ServerResponse contains the HTTP response code and headers from the
        	// server.
        	googleapi.ServerResponse `json:"-"`
        
        	// ForceSendFields is a list of field names (e.g. "CurrentState") 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. "CurrentState") 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:"-"`
        }

          AchievementResetResponse: This is a JSON template for an achievement reset response.

          func (*AchievementResetResponse) MarshalJSON

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

          type AchievementsResetAllCall

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

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

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

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

                func (*AchievementsResetAllCall) Header

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

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

                  type AchievementsResetAllForAllPlayersCall

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

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

                      Do executes the "gamesManagement.achievements.resetAllForAllPlayers" call.

                      func (*AchievementsResetAllForAllPlayersCall) Fields

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

                        func (*AchievementsResetAllForAllPlayersCall) Header

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

                          type AchievementsResetCall

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

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

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

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

                                func (*AchievementsResetCall) Header

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

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

                                  type AchievementsResetForAllPlayersCall

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

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

                                      Do executes the "gamesManagement.achievements.resetForAllPlayers" call.

                                      func (*AchievementsResetForAllPlayersCall) Fields

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

                                        func (*AchievementsResetForAllPlayersCall) Header

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

                                          type AchievementsResetMultipleForAllPlayersCall

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

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

                                              Do executes the "gamesManagement.achievements.resetMultipleForAllPlayers" call.

                                              func (*AchievementsResetMultipleForAllPlayersCall) Fields

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

                                                func (*AchievementsResetMultipleForAllPlayersCall) Header

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

                                                  type AchievementsService

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

                                                  func NewAchievementsService

                                                  func NewAchievementsService(s *Service) *AchievementsService

                                                  func (*AchievementsService) Reset

                                                  func (r *AchievementsService) Reset(achievementId string) *AchievementsResetCall

                                                    Reset: Resets the achievement with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application.

                                                    func (*AchievementsService) ResetAll

                                                      ResetAll: Resets all achievements for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application.

                                                      func (*AchievementsService) ResetAllForAllPlayers

                                                      func (r *AchievementsService) ResetAllForAllPlayers() *AchievementsResetAllForAllPlayersCall

                                                        ResetAllForAllPlayers: Resets all draft achievements for all players. This method is only available to user accounts for your developer console.

                                                        func (*AchievementsService) ResetForAllPlayers

                                                        func (r *AchievementsService) ResetForAllPlayers(achievementId string) *AchievementsResetForAllPlayersCall

                                                          ResetForAllPlayers: Resets the achievement with the given ID for all players. This method is only available to user accounts for your developer console. Only draft achievements can be reset.

                                                          func (*AchievementsService) ResetMultipleForAllPlayers

                                                          func (r *AchievementsService) ResetMultipleForAllPlayers(achievementresetmultipleforallrequest *AchievementResetMultipleForAllRequest) *AchievementsResetMultipleForAllPlayersCall

                                                            ResetMultipleForAllPlayers: Resets achievements with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft achievements may be reset.

                                                            type ApplicationsListHiddenCall

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

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

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

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

                                                                  func (*ApplicationsListHiddenCall) Header

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

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

                                                                      func (c *ApplicationsListHiddenCall) MaxResults(maxResults int64) *ApplicationsListHiddenCall

                                                                        MaxResults sets the optional parameter "maxResults": The maximum number of player resources to return in the response, used for paging. For any response, the actual number of player resources returned may be less than the specified maxResults.

                                                                        func (*ApplicationsListHiddenCall) PageToken

                                                                          PageToken sets the optional parameter "pageToken": The token returned by the previous request.

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

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

                                                                            func NewApplicationsService

                                                                            func NewApplicationsService(s *Service) *ApplicationsService

                                                                            func (*ApplicationsService) ListHidden

                                                                            func (r *ApplicationsService) ListHidden(applicationId string) *ApplicationsListHiddenCall

                                                                              ListHidden: Get the list of players hidden from the given application. This method is only available to user accounts for your developer console.

                                                                              type EventsResetAllCall

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

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

                                                                                  Do executes the "gamesManagement.events.resetAll" call.

                                                                                  func (*EventsResetAllCall) Fields

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

                                                                                    func (*EventsResetAllCall) Header

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

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

                                                                                      type EventsResetAllForAllPlayersCall

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

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

                                                                                          Do executes the "gamesManagement.events.resetAllForAllPlayers" call.

                                                                                          func (*EventsResetAllForAllPlayersCall) Fields

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

                                                                                            func (*EventsResetAllForAllPlayersCall) Header

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

                                                                                              type EventsResetCall

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

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

                                                                                                func (c *EventsResetCall) Do(opts ...googleapi.CallOption) error

                                                                                                  Do executes the "gamesManagement.events.reset" call.

                                                                                                  func (*EventsResetCall) Fields

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

                                                                                                    func (*EventsResetCall) Header

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

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

                                                                                                      type EventsResetForAllPlayersCall

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

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

                                                                                                          Do executes the "gamesManagement.events.resetForAllPlayers" call.

                                                                                                          func (*EventsResetForAllPlayersCall) Fields

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

                                                                                                            func (*EventsResetForAllPlayersCall) Header

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

                                                                                                              type EventsResetMultipleForAllPlayersCall

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

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

                                                                                                                  Do executes the "gamesManagement.events.resetMultipleForAllPlayers" call.

                                                                                                                  func (*EventsResetMultipleForAllPlayersCall) Fields

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

                                                                                                                    func (*EventsResetMultipleForAllPlayersCall) Header

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

                                                                                                                      type EventsResetMultipleForAllRequest

                                                                                                                      type EventsResetMultipleForAllRequest struct {
                                                                                                                      	// EventIds: The IDs of events to reset.
                                                                                                                      	EventIds []string `json:"event_ids,omitempty"`
                                                                                                                      
                                                                                                                      	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                      	// the fixed string gamesManagement#eventsResetMultipleForAllRequest.
                                                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                                                      
                                                                                                                      	// ForceSendFields is a list of field names (e.g. "EventIds") 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. "EventIds") 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:"-"`
                                                                                                                      }

                                                                                                                        EventsResetMultipleForAllRequest: This is a JSON template for multiple events reset all request.

                                                                                                                        func (*EventsResetMultipleForAllRequest) MarshalJSON

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

                                                                                                                        type EventsService

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

                                                                                                                        func NewEventsService

                                                                                                                        func NewEventsService(s *Service) *EventsService

                                                                                                                        func (*EventsService) Reset

                                                                                                                        func (r *EventsService) Reset(eventId string) *EventsResetCall

                                                                                                                          Reset: Resets all player progress on the event with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. All quests for this player that use the event will also be reset.

                                                                                                                          func (*EventsService) ResetAll

                                                                                                                          func (r *EventsService) ResetAll() *EventsResetAllCall

                                                                                                                            ResetAll: Resets all player progress on all events for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application. All quests for this player will also be reset.

                                                                                                                            func (*EventsService) ResetAllForAllPlayers

                                                                                                                            func (r *EventsService) ResetAllForAllPlayers() *EventsResetAllForAllPlayersCall

                                                                                                                              ResetAllForAllPlayers: Resets all draft events for all players. This method is only available to user accounts for your developer console. All quests that use any of these events will also be reset.

                                                                                                                              func (*EventsService) ResetForAllPlayers

                                                                                                                              func (r *EventsService) ResetForAllPlayers(eventId string) *EventsResetForAllPlayersCall

                                                                                                                                ResetForAllPlayers: Resets the event with the given ID for all players. This method is only available to user accounts for your developer console. Only draft events can be reset. All quests that use the event will also be reset.

                                                                                                                                func (*EventsService) ResetMultipleForAllPlayers

                                                                                                                                func (r *EventsService) ResetMultipleForAllPlayers(eventsresetmultipleforallrequest *EventsResetMultipleForAllRequest) *EventsResetMultipleForAllPlayersCall

                                                                                                                                  ResetMultipleForAllPlayers: Resets events with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft events may be reset. All quests that use any of the events will also be reset.

                                                                                                                                  type GamesPlayedResource

                                                                                                                                  type GamesPlayedResource struct {
                                                                                                                                  	// AutoMatched: True if the player was auto-matched with the currently
                                                                                                                                  	// authenticated user.
                                                                                                                                  	AutoMatched bool `json:"autoMatched,omitempty"`
                                                                                                                                  
                                                                                                                                  	// TimeMillis: The last time the player played the game in milliseconds
                                                                                                                                  	// since the epoch in UTC.
                                                                                                                                  	TimeMillis int64 `json:"timeMillis,omitempty,string"`
                                                                                                                                  
                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "AutoMatched") 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. "AutoMatched") 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:"-"`
                                                                                                                                  }

                                                                                                                                    GamesPlayedResource: This is a JSON template for metadata about a player playing a game with the currently authenticated user.

                                                                                                                                    func (*GamesPlayedResource) MarshalJSON

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

                                                                                                                                    type GamesPlayerExperienceInfoResource

                                                                                                                                    type GamesPlayerExperienceInfoResource struct {
                                                                                                                                    	// CurrentExperiencePoints: The current number of experience points for
                                                                                                                                    	// the player.
                                                                                                                                    	CurrentExperiencePoints int64 `json:"currentExperiencePoints,omitempty,string"`
                                                                                                                                    
                                                                                                                                    	// CurrentLevel: The current level of the player.
                                                                                                                                    	CurrentLevel *GamesPlayerLevelResource `json:"currentLevel,omitempty"`
                                                                                                                                    
                                                                                                                                    	// LastLevelUpTimestampMillis: The timestamp when the player was leveled
                                                                                                                                    	// up, in millis since Unix epoch UTC.
                                                                                                                                    	LastLevelUpTimestampMillis int64 `json:"lastLevelUpTimestampMillis,omitempty,string"`
                                                                                                                                    
                                                                                                                                    	// NextLevel: The next level of the player. If the current level is the
                                                                                                                                    	// maximum level, this should be same as the current level.
                                                                                                                                    	NextLevel *GamesPlayerLevelResource `json:"nextLevel,omitempty"`
                                                                                                                                    
                                                                                                                                    	// ForceSendFields is a list of field names (e.g.
                                                                                                                                    	// "CurrentExperiencePoints") 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. "CurrentExperiencePoints")
                                                                                                                                    	// 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:"-"`
                                                                                                                                    }

                                                                                                                                      GamesPlayerExperienceInfoResource: This is a JSON template for 1P/3P metadata about the player's experience.

                                                                                                                                      func (*GamesPlayerExperienceInfoResource) MarshalJSON

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

                                                                                                                                      type GamesPlayerLevelResource

                                                                                                                                      type GamesPlayerLevelResource struct {
                                                                                                                                      	// Level: The level for the user.
                                                                                                                                      	Level int64 `json:"level,omitempty"`
                                                                                                                                      
                                                                                                                                      	// MaxExperiencePoints: The maximum experience points for this level.
                                                                                                                                      	MaxExperiencePoints int64 `json:"maxExperiencePoints,omitempty,string"`
                                                                                                                                      
                                                                                                                                      	// MinExperiencePoints: The minimum experience points for this level.
                                                                                                                                      	MinExperiencePoints int64 `json:"minExperiencePoints,omitempty,string"`
                                                                                                                                      
                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Level") 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. "Level") 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:"-"`
                                                                                                                                      }

                                                                                                                                        GamesPlayerLevelResource: This is a JSON template for 1P/3P metadata about a user's level.

                                                                                                                                        func (*GamesPlayerLevelResource) MarshalJSON

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

                                                                                                                                        type HiddenPlayer

                                                                                                                                        type HiddenPlayer struct {
                                                                                                                                        	// HiddenTimeMillis: The time this player was hidden.
                                                                                                                                        	HiddenTimeMillis int64 `json:"hiddenTimeMillis,omitempty,string"`
                                                                                                                                        
                                                                                                                                        	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                        	// the fixed string gamesManagement#hiddenPlayer.
                                                                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Player: The player information.
                                                                                                                                        	Player *Player `json:"player,omitempty"`
                                                                                                                                        
                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "HiddenTimeMillis") 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. "HiddenTimeMillis") 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:"-"`
                                                                                                                                        }

                                                                                                                                          HiddenPlayer: This is a JSON template for the HiddenPlayer resource.

                                                                                                                                          func (*HiddenPlayer) MarshalJSON

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

                                                                                                                                          type HiddenPlayerList

                                                                                                                                          type HiddenPlayerList struct {
                                                                                                                                          	// Items: The players.
                                                                                                                                          	Items []*HiddenPlayer `json:"items,omitempty"`
                                                                                                                                          
                                                                                                                                          	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                          	// the fixed string gamesManagement#hiddenPlayerList.
                                                                                                                                          	Kind string `json:"kind,omitempty"`
                                                                                                                                          
                                                                                                                                          	// NextPageToken: The pagination token for the next page of results.
                                                                                                                                          	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                          
                                                                                                                                          	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                          	// server.
                                                                                                                                          	googleapi.ServerResponse `json:"-"`
                                                                                                                                          
                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "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:"-"`
                                                                                                                                          }

                                                                                                                                            HiddenPlayerList: This is a JSON template for a list of hidden players.

                                                                                                                                            func (*HiddenPlayerList) MarshalJSON

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

                                                                                                                                            type Player

                                                                                                                                            type Player struct {
                                                                                                                                            	// AvatarImageUrl: The base URL for the image that represents the
                                                                                                                                            	// player.
                                                                                                                                            	AvatarImageUrl string `json:"avatarImageUrl,omitempty"`
                                                                                                                                            
                                                                                                                                            	// BannerUrlLandscape: The url to the landscape mode player banner
                                                                                                                                            	// image.
                                                                                                                                            	BannerUrlLandscape string `json:"bannerUrlLandscape,omitempty"`
                                                                                                                                            
                                                                                                                                            	// BannerUrlPortrait: The url to the portrait mode player banner image.
                                                                                                                                            	BannerUrlPortrait string `json:"bannerUrlPortrait,omitempty"`
                                                                                                                                            
                                                                                                                                            	// DisplayName: The name to display for the player.
                                                                                                                                            	DisplayName string `json:"displayName,omitempty"`
                                                                                                                                            
                                                                                                                                            	// ExperienceInfo: An object to represent Play Game experience
                                                                                                                                            	// information for the player.
                                                                                                                                            	ExperienceInfo *GamesPlayerExperienceInfoResource `json:"experienceInfo,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                            	// the fixed string gamesManagement#player.
                                                                                                                                            	Kind string `json:"kind,omitempty"`
                                                                                                                                            
                                                                                                                                            	// LastPlayedWith: Details about the last time this player played a
                                                                                                                                            	// multiplayer game with the currently authenticated player. Populated
                                                                                                                                            	// for PLAYED_WITH player collection members.
                                                                                                                                            	LastPlayedWith *GamesPlayedResource `json:"lastPlayedWith,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Name: An object representation of the individual components of the
                                                                                                                                            	// player's name. For some players, these fields may not be present.
                                                                                                                                            	Name *PlayerName `json:"name,omitempty"`
                                                                                                                                            
                                                                                                                                            	// OriginalPlayerId: The player ID that was used for this player the
                                                                                                                                            	// first time they signed into the game in question. This is only
                                                                                                                                            	// populated for calls to player.get for the requesting player, only if
                                                                                                                                            	// the player ID has subsequently changed, and only to clients that
                                                                                                                                            	// support remapping player IDs.
                                                                                                                                            	OriginalPlayerId string `json:"originalPlayerId,omitempty"`
                                                                                                                                            
                                                                                                                                            	// PlayerId: The ID of the player.
                                                                                                                                            	PlayerId string `json:"playerId,omitempty"`
                                                                                                                                            
                                                                                                                                            	PlayerStattus string `json:"playerStattus,omitempty"`
                                                                                                                                            
                                                                                                                                            	// ProfileSettings: The player's profile settings. Controls whether or
                                                                                                                                            	// not the player's profile is visible to other players.
                                                                                                                                            	ProfileSettings *ProfileSettings `json:"profileSettings,omitempty"`
                                                                                                                                            
                                                                                                                                            	// Title: The player's title rewarded for their game activities.
                                                                                                                                            	Title string `json:"title,omitempty"`
                                                                                                                                            
                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "AvatarImageUrl") 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. "AvatarImageUrl") 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:"-"`
                                                                                                                                            }

                                                                                                                                              Player: This is a JSON template for a Player resource.

                                                                                                                                              func (*Player) MarshalJSON

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

                                                                                                                                              type PlayerName

                                                                                                                                              type PlayerName struct {
                                                                                                                                              	// FamilyName: The family name of this player. In some places, this is
                                                                                                                                              	// known as the last name.
                                                                                                                                              	FamilyName string `json:"familyName,omitempty"`
                                                                                                                                              
                                                                                                                                              	// GivenName: The given name of this player. In some places, this is
                                                                                                                                              	// known as the first name.
                                                                                                                                              	GivenName string `json:"givenName,omitempty"`
                                                                                                                                              
                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "FamilyName") 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. "FamilyName") 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:"-"`
                                                                                                                                              }

                                                                                                                                                PlayerName: An object representation of the individual components of the player's name. For some players, these fields may not be present.

                                                                                                                                                func (*PlayerName) MarshalJSON

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

                                                                                                                                                type PlayerScoreResetAllResponse

                                                                                                                                                type PlayerScoreResetAllResponse struct {
                                                                                                                                                	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                                	// the fixed string gamesManagement#playerScoreResetResponse.
                                                                                                                                                	Kind string `json:"kind,omitempty"`
                                                                                                                                                
                                                                                                                                                	// Results: The leaderboard reset results.
                                                                                                                                                	Results []*PlayerScoreResetResponse `json:"results,omitempty"`
                                                                                                                                                
                                                                                                                                                	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                	// server.
                                                                                                                                                	googleapi.ServerResponse `json:"-"`
                                                                                                                                                
                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Kind") 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. "Kind") 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:"-"`
                                                                                                                                                }

                                                                                                                                                  PlayerScoreResetAllResponse: This is a JSON template for a list of leaderboard reset resources.

                                                                                                                                                  func (*PlayerScoreResetAllResponse) MarshalJSON

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

                                                                                                                                                  type PlayerScoreResetResponse

                                                                                                                                                  type PlayerScoreResetResponse struct {
                                                                                                                                                  	// DefinitionId: The ID of an leaderboard for which player state has
                                                                                                                                                  	// been updated.
                                                                                                                                                  	DefinitionId string `json:"definitionId,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                                  	// the fixed string gamesManagement#playerScoreResetResponse.
                                                                                                                                                  	Kind string `json:"kind,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// ResetScoreTimeSpans: The time spans of the updated score.
                                                                                                                                                  	// Possible values are:
                                                                                                                                                  	// - "ALL_TIME" - The score is an all-time score.
                                                                                                                                                  	// - "WEEKLY" - The score is a weekly score.
                                                                                                                                                  	// - "DAILY" - The score is a daily score.
                                                                                                                                                  	ResetScoreTimeSpans []string `json:"resetScoreTimeSpans,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                  	// server.
                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                  
                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "DefinitionId") 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. "DefinitionId") 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:"-"`
                                                                                                                                                  }

                                                                                                                                                    PlayerScoreResetResponse: This is a JSON template for a list of reset leaderboard entry resources.

                                                                                                                                                    func (*PlayerScoreResetResponse) MarshalJSON

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

                                                                                                                                                    type PlayersHideCall

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

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

                                                                                                                                                      func (c *PlayersHideCall) Do(opts ...googleapi.CallOption) error

                                                                                                                                                        Do executes the "gamesManagement.players.hide" call.

                                                                                                                                                        func (*PlayersHideCall) Fields

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

                                                                                                                                                          func (*PlayersHideCall) Header

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

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

                                                                                                                                                            type PlayersService

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

                                                                                                                                                            func NewPlayersService

                                                                                                                                                            func NewPlayersService(s *Service) *PlayersService

                                                                                                                                                            func (*PlayersService) Hide

                                                                                                                                                            func (r *PlayersService) Hide(applicationId string, playerId string) *PlayersHideCall

                                                                                                                                                              Hide: Hide the given player's leaderboard scores from the given application. This method is only available to user accounts for your developer console.

                                                                                                                                                              func (*PlayersService) Unhide

                                                                                                                                                              func (r *PlayersService) Unhide(applicationId string, playerId string) *PlayersUnhideCall

                                                                                                                                                                Unhide: Unhide the given player's leaderboard scores from the given application. This method is only available to user accounts for your developer console.

                                                                                                                                                                type PlayersUnhideCall

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

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

                                                                                                                                                                    Do executes the "gamesManagement.players.unhide" call.

                                                                                                                                                                    func (*PlayersUnhideCall) Fields

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

                                                                                                                                                                      func (*PlayersUnhideCall) Header

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

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

                                                                                                                                                                        type ProfileSettings

                                                                                                                                                                        type ProfileSettings struct {
                                                                                                                                                                        	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                                                        	// the fixed string gamesManagement#profileSettings.
                                                                                                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                                                                                                        
                                                                                                                                                                        	ProfileVisible bool `json:"profileVisible,omitempty"`
                                                                                                                                                                        
                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Kind") 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. "Kind") 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:"-"`
                                                                                                                                                                        }

                                                                                                                                                                          ProfileSettings: This is a JSON template for profile settings

                                                                                                                                                                          func (*ProfileSettings) MarshalJSON

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

                                                                                                                                                                          type RoomsResetCall

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

                                                                                                                                                                          func (*RoomsResetCall) Context

                                                                                                                                                                          func (c *RoomsResetCall) Context(ctx context.Context) *RoomsResetCall

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

                                                                                                                                                                            func (c *RoomsResetCall) Do(opts ...googleapi.CallOption) error

                                                                                                                                                                              Do executes the "gamesManagement.rooms.reset" call.

                                                                                                                                                                              func (*RoomsResetCall) Fields

                                                                                                                                                                              func (c *RoomsResetCall) Fields(s ...googleapi.Field) *RoomsResetCall

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

                                                                                                                                                                                func (*RoomsResetCall) Header

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

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

                                                                                                                                                                                  type RoomsResetForAllPlayersCall

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

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

                                                                                                                                                                                      Do executes the "gamesManagement.rooms.resetForAllPlayers" call.

                                                                                                                                                                                      func (*RoomsResetForAllPlayersCall) Fields

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

                                                                                                                                                                                        func (*RoomsResetForAllPlayersCall) Header

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

                                                                                                                                                                                          type RoomsService

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

                                                                                                                                                                                          func NewRoomsService

                                                                                                                                                                                          func NewRoomsService(s *Service) *RoomsService

                                                                                                                                                                                          func (*RoomsService) Reset

                                                                                                                                                                                          func (r *RoomsService) Reset() *RoomsResetCall

                                                                                                                                                                                            Reset: Reset all rooms for the currently authenticated player for your application. This method is only accessible to whitelisted tester accounts for your application.

                                                                                                                                                                                            func (*RoomsService) ResetForAllPlayers

                                                                                                                                                                                            func (r *RoomsService) ResetForAllPlayers() *RoomsResetForAllPlayersCall

                                                                                                                                                                                              ResetForAllPlayers: Deletes rooms where the only room participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console.

                                                                                                                                                                                              type ScoresResetAllCall

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

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

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

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

                                                                                                                                                                                                    func (*ScoresResetAllCall) Header

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

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

                                                                                                                                                                                                      type ScoresResetAllForAllPlayersCall

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

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

                                                                                                                                                                                                          Do executes the "gamesManagement.scores.resetAllForAllPlayers" call.

                                                                                                                                                                                                          func (*ScoresResetAllForAllPlayersCall) Fields

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

                                                                                                                                                                                                            func (*ScoresResetAllForAllPlayersCall) Header

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

                                                                                                                                                                                                              type ScoresResetCall

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

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

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

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

                                                                                                                                                                                                                    func (*ScoresResetCall) Header

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

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

                                                                                                                                                                                                                      type ScoresResetForAllPlayersCall

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

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

                                                                                                                                                                                                                          Do executes the "gamesManagement.scores.resetForAllPlayers" call.

                                                                                                                                                                                                                          func (*ScoresResetForAllPlayersCall) Fields

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

                                                                                                                                                                                                                            func (*ScoresResetForAllPlayersCall) Header

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

                                                                                                                                                                                                                              type ScoresResetMultipleForAllPlayersCall

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

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

                                                                                                                                                                                                                                  Do executes the "gamesManagement.scores.resetMultipleForAllPlayers" call.

                                                                                                                                                                                                                                  func (*ScoresResetMultipleForAllPlayersCall) Fields

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

                                                                                                                                                                                                                                    func (*ScoresResetMultipleForAllPlayersCall) Header

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

                                                                                                                                                                                                                                      type ScoresResetMultipleForAllRequest

                                                                                                                                                                                                                                      type ScoresResetMultipleForAllRequest struct {
                                                                                                                                                                                                                                      	// Kind: Uniquely identifies the type of this resource. Value is always
                                                                                                                                                                                                                                      	// the fixed string gamesManagement#scoresResetMultipleForAllRequest.
                                                                                                                                                                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// LeaderboardIds: The IDs of leaderboards to reset.
                                                                                                                                                                                                                                      	LeaderboardIds []string `json:"leaderboard_ids,omitempty"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Kind") 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. "Kind") 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:"-"`
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        ScoresResetMultipleForAllRequest: This is a JSON template for multiple scores reset all request.

                                                                                                                                                                                                                                        func (*ScoresResetMultipleForAllRequest) MarshalJSON

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

                                                                                                                                                                                                                                        type ScoresService

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

                                                                                                                                                                                                                                        func NewScoresService

                                                                                                                                                                                                                                        func NewScoresService(s *Service) *ScoresService

                                                                                                                                                                                                                                        func (*ScoresService) Reset

                                                                                                                                                                                                                                        func (r *ScoresService) Reset(leaderboardId string) *ScoresResetCall

                                                                                                                                                                                                                                          Reset: Resets scores for the leaderboard with the given ID for the currently authenticated player. This method is only accessible to whitelisted tester accounts for your application.

                                                                                                                                                                                                                                          func (*ScoresService) ResetAll

                                                                                                                                                                                                                                          func (r *ScoresService) ResetAll() *ScoresResetAllCall

                                                                                                                                                                                                                                            ResetAll: Resets all scores for all leaderboards for the currently authenticated players. This method is only accessible to whitelisted tester accounts for your application.

                                                                                                                                                                                                                                            func (*ScoresService) ResetAllForAllPlayers

                                                                                                                                                                                                                                            func (r *ScoresService) ResetAllForAllPlayers() *ScoresResetAllForAllPlayersCall

                                                                                                                                                                                                                                              ResetAllForAllPlayers: Resets scores for all draft leaderboards for all players. This method is only available to user accounts for your developer console.

                                                                                                                                                                                                                                              func (*ScoresService) ResetForAllPlayers

                                                                                                                                                                                                                                              func (r *ScoresService) ResetForAllPlayers(leaderboardId string) *ScoresResetForAllPlayersCall

                                                                                                                                                                                                                                                ResetForAllPlayers: Resets scores for the leaderboard with the given ID for all players. This method is only available to user accounts for your developer console. Only draft leaderboards can be reset.

                                                                                                                                                                                                                                                func (*ScoresService) ResetMultipleForAllPlayers

                                                                                                                                                                                                                                                func (r *ScoresService) ResetMultipleForAllPlayers(scoresresetmultipleforallrequest *ScoresResetMultipleForAllRequest) *ScoresResetMultipleForAllPlayersCall

                                                                                                                                                                                                                                                  ResetMultipleForAllPlayers: Resets scores for the leaderboards with the given IDs for all players. This method is only available to user accounts for your developer console. Only draft leaderboards may be reset.

                                                                                                                                                                                                                                                  type Service

                                                                                                                                                                                                                                                  type Service struct {
                                                                                                                                                                                                                                                  	BasePath  string // API endpoint base URL
                                                                                                                                                                                                                                                  	UserAgent string // optional additional User-Agent fragment
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Achievements *AchievementsService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Applications *ApplicationsService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Events *EventsService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Players *PlayersService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Rooms *RoomsService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	Scores *ScoresService
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	TurnBasedMatches *TurnBasedMatchesService
                                                                                                                                                                                                                                                  	// 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 TurnBasedMatchesResetCall

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

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

                                                                                                                                                                                                                                                          Do executes the "gamesManagement.turnBasedMatches.reset" call.

                                                                                                                                                                                                                                                          func (*TurnBasedMatchesResetCall) Fields

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

                                                                                                                                                                                                                                                            func (*TurnBasedMatchesResetCall) Header

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

                                                                                                                                                                                                                                                              type TurnBasedMatchesResetForAllPlayersCall

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

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

                                                                                                                                                                                                                                                                  Do executes the "gamesManagement.turnBasedMatches.resetForAllPlayers" call.

                                                                                                                                                                                                                                                                  func (*TurnBasedMatchesResetForAllPlayersCall) Fields

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

                                                                                                                                                                                                                                                                    func (*TurnBasedMatchesResetForAllPlayersCall) Header

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

                                                                                                                                                                                                                                                                      type TurnBasedMatchesService

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

                                                                                                                                                                                                                                                                      func NewTurnBasedMatchesService

                                                                                                                                                                                                                                                                      func NewTurnBasedMatchesService(s *Service) *TurnBasedMatchesService

                                                                                                                                                                                                                                                                      func (*TurnBasedMatchesService) Reset

                                                                                                                                                                                                                                                                        Reset: Reset all turn-based match data for a user. This method is only accessible to whitelisted tester accounts for your application.

                                                                                                                                                                                                                                                                        func (*TurnBasedMatchesService) ResetForAllPlayers

                                                                                                                                                                                                                                                                          ResetForAllPlayers: Deletes turn-based matches where the only match participants are from whitelisted tester accounts for your application. This method is only available to user accounts for your developer console.