// Copyright 2026 Google LLC.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Code generated file. DO NOT EDIT.

// Package health provides access to the Google Health API.
//
// For product documentation, see: https://developers.google.com/health
//
// # Library status
//
// These client libraries are officially supported by Google. However, this
// library is considered complete and is in maintenance mode. This means
// that we will address critical bugs and security issues but will not add
// any new features.
//
// When possible, we recommend using our newer
// [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go)
// that are still actively being worked and iterated on.
//
// # Creating a client
//
// Usage example:
//
//	import "google.golang.org/api/health/v4"
//	...
//	ctx := context.Background()
//	healthService, err := health.NewService(ctx)
//
// In this example, Google Application Default Credentials are used for
// authentication. For information on how to create and obtain Application
// Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.
//
// # Other authentication options
//
// By default, all available scopes (see "Constants") are used to authenticate.
// To restrict scopes, use [google.golang.org/api/option.WithScopes]:
//
//	healthService, err := health.NewService(ctx, option.WithScopes(health.GooglehealthSleepWriteonlyScope))
//
// To use an API key for authentication (note: some APIs do not support API
// keys), use [google.golang.org/api/option.WithAPIKey]:
//
//	healthService, err := health.NewService(ctx, option.WithAPIKey("AIza..."))
//
// To use an OAuth token (e.g., a user token obtained via a three-legged OAuth
// flow, use [google.golang.org/api/option.WithTokenSource]:
//
//	config := &oauth2.Config{...}
//	// ...
//	token, err := config.Exchange(ctx, ...)
//	healthService, err := health.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
//
// See [google.golang.org/api/option.ClientOption] for details on options.
package health // import "google.golang.org/api/health/v4"

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/googleapis/gax-go/v2/internallog"
	googleapi "google.golang.org/api/googleapi"
	internal "google.golang.org/api/internal"
	gensupport "google.golang.org/api/internal/gensupport"
	option "google.golang.org/api/option"
	internaloption "google.golang.org/api/option/internaloption"
	htransport "google.golang.org/api/transport/http"
)

// Always reference these packages, just in case the auto-generated code
// below doesn't.
var _ = bytes.NewBuffer
var _ = strconv.Itoa
var _ = fmt.Sprintf
var _ = json.NewDecoder
var _ = io.Copy
var _ = url.Parse
var _ = gensupport.MarshalJSON
var _ = googleapi.Version
var _ = errors.New
var _ = strings.Replace
var _ = context.Canceled
var _ = internaloption.WithDefaultEndpoint
var _ = internal.Version
var _ = internallog.New

const apiId = "health:v4"
const apiName = "health"
const apiVersion = "v4"
const basePath = "https://health.googleapis.com/"
const basePathTemplate = "https://health.UNIVERSE_DOMAIN/"
const mtlsBasePath = "https://health.mtls.googleapis.com/"

// OAuth2 scopes used by this API.
const (
	// See, edit, configure, and delete your Google Cloud data and see the email
	// address for your Google Account.
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"

	// See your Google Health activity and fitness data
	GooglehealthActivityAndFitnessReadonlyScope = "https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly"

	// Add activity and fitness data to Google Health, and edit or delete the data
	// it adds.
	GooglehealthActivityAndFitnessWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.activity_and_fitness.writeonly"

	// See your Google Health ECG data
	GooglehealthEcgReadonlyScope = "https://www.googleapis.com/auth/googlehealth.ecg.readonly"

	// See your Google Health health metrics and measurement data
	GooglehealthHealthMetricsAndMeasurementsReadonlyScope = "https://www.googleapis.com/auth/googlehealth.health_metrics_and_measurements.readonly"

	// Add health metric and measurements data to Google Health, and edit or delete
	// the data it adds.
	GooglehealthHealthMetricsAndMeasurementsWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.health_metrics_and_measurements.writeonly"

	// See your Google Health Irregular Rhythm Notifications data
	GooglehealthIrnReadonlyScope = "https://www.googleapis.com/auth/googlehealth.irn.readonly"

	// See exercise GPS location data in Google Health
	GooglehealthLocationReadonlyScope = "https://www.googleapis.com/auth/googlehealth.location.readonly"

	// See your Google Health logged symptoms data
	GooglehealthLoggedSymptomsReadonlyScope = "https://www.googleapis.com/auth/googlehealth.logged_symptoms.readonly"

	// Add logged symptoms data to Google Health, and edit or delete the data it
	// adds
	GooglehealthLoggedSymptomsWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.logged_symptoms.writeonly"

	// See your Google Health mindfulness data
	GooglehealthMindfulnessReadonlyScope = "https://www.googleapis.com/auth/googlehealth.mindfulness.readonly"

	// Add mindfulness data to Google Health, and edit or delete the data it adds
	GooglehealthMindfulnessWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.mindfulness.writeonly"

	// Add nutrition data to Google Health, and edit or delete the data it adds.
	GooglehealthNutritionWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.nutrition.writeonly"

	// See your Google Health profile data
	GooglehealthProfileReadonlyScope = "https://www.googleapis.com/auth/googlehealth.profile.readonly"

	// Add profile data to Google Health, and edit or delete the data it adds.
	GooglehealthProfileWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.profile.writeonly"

	// See your Google Health reproductive health data
	GooglehealthReproductiveHealthReadonlyScope = "https://www.googleapis.com/auth/googlehealth.reproductive_health.readonly"

	// Add reproductive health data to Google Health, and edit or delete the data
	// it adds
	GooglehealthReproductiveHealthWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.reproductive_health.writeonly"

	// See your Google Health settings
	GooglehealthSettingsReadonlyScope = "https://www.googleapis.com/auth/googlehealth.settings.readonly"

	// Add settings data to Google Health, and edit or delete the data it adds.
	GooglehealthSettingsWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.settings.writeonly"

	// See your Google Health sleep data
	GooglehealthSleepReadonlyScope = "https://www.googleapis.com/auth/googlehealth.sleep.readonly"

	// Add sleep data to Google Health, and edit or delete the data it adds.
	GooglehealthSleepWriteonlyScope = "https://www.googleapis.com/auth/googlehealth.sleep.writeonly"
)

// NewService creates a new Service.
func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
	scopesOption := internaloption.WithDefaultScopes(
		"https://www.googleapis.com/auth/cloud-platform",
		"https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly",
		"https://www.googleapis.com/auth/googlehealth.activity_and_fitness.writeonly",
		"https://www.googleapis.com/auth/googlehealth.ecg.readonly",
		"https://www.googleapis.com/auth/googlehealth.health_metrics_and_measurements.readonly",
		"https://www.googleapis.com/auth/googlehealth.health_metrics_and_measurements.writeonly",
		"https://www.googleapis.com/auth/googlehealth.irn.readonly",
		"https://www.googleapis.com/auth/googlehealth.location.readonly",
		"https://www.googleapis.com/auth/googlehealth.logged_symptoms.readonly",
		"https://www.googleapis.com/auth/googlehealth.logged_symptoms.writeonly",
		"https://www.googleapis.com/auth/googlehealth.mindfulness.readonly",
		"https://www.googleapis.com/auth/googlehealth.mindfulness.writeonly",
		"https://www.googleapis.com/auth/googlehealth.nutrition.writeonly",
		"https://www.googleapis.com/auth/googlehealth.profile.readonly",
		"https://www.googleapis.com/auth/googlehealth.profile.writeonly",
		"https://www.googleapis.com/auth/googlehealth.reproductive_health.readonly",
		"https://www.googleapis.com/auth/googlehealth.reproductive_health.writeonly",
		"https://www.googleapis.com/auth/googlehealth.settings.readonly",
		"https://www.googleapis.com/auth/googlehealth.settings.writeonly",
		"https://www.googleapis.com/auth/googlehealth.sleep.readonly",
		"https://www.googleapis.com/auth/googlehealth.sleep.writeonly",
	)
	// NOTE: prepend, so we don't override user-specified scopes.
	opts = append([]option.ClientOption{scopesOption}, opts...)
	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
	opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
	opts = append(opts, internaloption.EnableNewAuthLibrary())
	client, endpoint, err := htransport.NewClient(ctx, opts...)
	if err != nil {
		return nil, err
	}
	s := &Service{client: client, BasePath: basePath, logger: internaloption.GetLogger(opts)}
	s.Projects = NewProjectsService(s)
	s.Shl = NewShlService(s)
	s.Users = NewUsersService(s)
	if endpoint != "" {
		s.BasePath = endpoint
	}
	return s, nil
}

// 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 New(client *http.Client) (*Service, error) {
	if client == nil {
		return nil, errors.New("client is nil")
	}
	return NewService(context.TODO(), option.WithHTTPClient(client))
}

type Service struct {
	client    *http.Client
	logger    *slog.Logger
	BasePath  string // API endpoint base URL
	UserAgent string // optional additional User-Agent fragment

	Projects *ProjectsService

	Shl *ShlService

	Users *UsersService
}

func (s *Service) userAgent() string {
	if s.UserAgent == "" {
		return googleapi.UserAgent
	}
	return googleapi.UserAgent + " " + s.UserAgent
}

func NewProjectsService(s *Service) *ProjectsService {
	rs := &ProjectsService{s: s}
	rs.Subscribers = NewProjectsSubscribersService(s)
	return rs
}

type ProjectsService struct {
	s *Service

	Subscribers *ProjectsSubscribersService
}

func NewProjectsSubscribersService(s *Service) *ProjectsSubscribersService {
	rs := &ProjectsSubscribersService{s: s}
	rs.Subscriptions = NewProjectsSubscribersSubscriptionsService(s)
	return rs
}

type ProjectsSubscribersService struct {
	s *Service

	Subscriptions *ProjectsSubscribersSubscriptionsService
}

func NewProjectsSubscribersSubscriptionsService(s *Service) *ProjectsSubscribersSubscriptionsService {
	rs := &ProjectsSubscribersSubscriptionsService{s: s}
	return rs
}

type ProjectsSubscribersSubscriptionsService struct {
	s *Service
}

func NewShlService(s *Service) *ShlService {
	rs := &ShlService{s: s}
	rs.M = NewShlMService(s)
	rs.R = NewShlRService(s)
	return rs
}

type ShlService struct {
	s *Service

	M *ShlMService

	R *ShlRService
}

func NewShlMService(s *Service) *ShlMService {
	rs := &ShlMService{s: s}
	return rs
}

type ShlMService struct {
	s *Service
}

func NewShlRService(s *Service) *ShlRService {
	rs := &ShlRService{s: s}
	return rs
}

type ShlRService struct {
	s *Service
}

func NewUsersService(s *Service) *UsersService {
	rs := &UsersService{s: s}
	rs.DataTypes = NewUsersDataTypesService(s)
	rs.PairedDevices = NewUsersPairedDevicesService(s)
	return rs
}

type UsersService struct {
	s *Service

	DataTypes *UsersDataTypesService

	PairedDevices *UsersPairedDevicesService
}

func NewUsersDataTypesService(s *Service) *UsersDataTypesService {
	rs := &UsersDataTypesService{s: s}
	rs.DataPoints = NewUsersDataTypesDataPointsService(s)
	return rs
}

type UsersDataTypesService struct {
	s *Service

	DataPoints *UsersDataTypesDataPointsService
}

func NewUsersDataTypesDataPointsService(s *Service) *UsersDataTypesDataPointsService {
	rs := &UsersDataTypesDataPointsService{s: s}
	return rs
}

type UsersDataTypesDataPointsService struct {
	s *Service
}

func NewUsersPairedDevicesService(s *Service) *UsersPairedDevicesService {
	rs := &UsersPairedDevicesService{s: s}
	return rs
}

type UsersPairedDevicesService struct {
	s *Service
}

// ActiveEnergyBurned: Energy burned as part of an activity, excluding the
// basal energy burn.
type ActiveEnergyBurned struct {
	// Interval: Required. Observed interval
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// Kcal: Required. Energy burned during an activity, measured in kilocalories.
	Kcal float64 `json:"kcal,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveEnergyBurned) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveEnergyBurned
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *ActiveEnergyBurned) UnmarshalJSON(data []byte) error {
	type NoMethod ActiveEnergyBurned
	var s1 struct {
		Kcal gensupport.JSONFloat64 `json:"kcal"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Kcal = float64(s1.Kcal)
	return nil
}

// ActiveEnergyBurnedRollupValue: Represents the result of the rollup of active
// energy burned.
type ActiveEnergyBurnedRollupValue struct {
	// KcalSum: Output only. Sum of the active energy burned in kilocalories.
	KcalSum float64 `json:"kcalSum,omitempty"`
	// ForceSendFields is a list of field names (e.g. "KcalSum") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "KcalSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveEnergyBurnedRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveEnergyBurnedRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *ActiveEnergyBurnedRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod ActiveEnergyBurnedRollupValue
	var s1 struct {
		KcalSum gensupport.JSONFloat64 `json:"kcalSum"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.KcalSum = float64(s1.KcalSum)
	return nil
}

// ActiveMinutes: Record of active minutes in a given time interval.
type ActiveMinutes struct {
	// ActiveMinutesByActivityLevel: Required. Active minutes by activity level. At
	// most one record per activity level is allowed.
	ActiveMinutesByActivityLevel []*ActiveMinutesByActivityLevel `json:"activeMinutesByActivityLevel,omitempty"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "ActiveMinutesByActivityLevel") to unconditionally include in API requests.
	// By default, fields with empty or default values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields
	// for more details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveMinutesByActivityLevel") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveMinutes) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveMinutes
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActiveMinutesByActivityLevel: Active minutes at a given activity level.
type ActiveMinutesByActivityLevel struct {
	// ActiveMinutes: Required. Number of whole minutes spent in activity.
	ActiveMinutes int64 `json:"activeMinutes,omitempty,string"`
	// ActivityLevel: Required. The level of activity.
	//
	// Possible values:
	//   "ACTIVITY_LEVEL_UNSPECIFIED" - Activity level is unspecified.
	//   "LIGHT" - Light activity level.
	//   "MODERATE" - Moderate activity level.
	//   "VIGOROUS" - Vigorous activity level.
	ActivityLevel string `json:"activityLevel,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveMinutes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveMinutes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveMinutesByActivityLevel) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveMinutesByActivityLevel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActiveMinutesRollupByActivityLevel: Active minutes by activity level.
type ActiveMinutesRollupByActivityLevel struct {
	// ActiveMinutesSum: Number of whole minutes spent in activity.
	ActiveMinutesSum int64 `json:"activeMinutesSum,omitempty,string"`
	// ActivityLevel: The level of activity.
	//
	// Possible values:
	//   "ACTIVITY_LEVEL_UNSPECIFIED" - Activity level is unspecified.
	//   "LIGHT" - Light activity level.
	//   "MODERATE" - Moderate activity level.
	//   "VIGOROUS" - Vigorous activity level.
	ActivityLevel string `json:"activityLevel,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveMinutesSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveMinutesSum") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveMinutesRollupByActivityLevel) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveMinutesRollupByActivityLevel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActiveMinutesRollupValue: Represents the result of the rollup of the active
// minutes data type.
type ActiveMinutesRollupValue struct {
	// ActiveMinutesRollupByActivityLevel: Active minutes by activity level. At
	// most one record per activity level is allowed.
	ActiveMinutesRollupByActivityLevel []*ActiveMinutesRollupByActivityLevel `json:"activeMinutesRollupByActivityLevel,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "ActiveMinutesRollupByActivityLevel") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "ActiveMinutesRollupByActivityLevel") to include in API requests with the
	// JSON null value. By default, fields with empty values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields for
	// more details.
	NullFields []string `json:"-"`
}

func (s ActiveMinutesRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveMinutesRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActiveZoneMinutes: Record of active zone minutes in a given time interval.
type ActiveZoneMinutes struct {
	// ActiveZoneMinutes: Required. Number of Active Zone Minutes earned in the
	// given time interval. Note: active_zone_minutes equals to 1 for low intensity
	// (fat burn) zones or 2 for high intensity zones (cardio, peak).
	ActiveZoneMinutes int64 `json:"activeZoneMinutes,omitempty,string"`
	// HeartRateZone: Required. Heart rate zone in which the active zone minutes
	// have been earned, in the given time interval.
	//
	// Possible values:
	//   "HEART_RATE_ZONE_UNSPECIFIED" - Unspecified heart rate zone.
	//   "FAT_BURN" - The fat burn heart rate zone.
	//   "CARDIO" - The cardio heart rate zone.
	//   "PEAK" - The peak heart rate zone.
	HeartRateZone string `json:"heartRateZone,omitempty"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveZoneMinutes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveZoneMinutes") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveZoneMinutes) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveZoneMinutes
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActiveZoneMinutesRollupValue: Represents the result of the rollup of the
// active zone minutes data type.
type ActiveZoneMinutesRollupValue struct {
	// SumInCardioHeartZone: Active zone minutes in `HeartRateZone.CARDIO`.
	SumInCardioHeartZone int64 `json:"sumInCardioHeartZone,omitempty,string"`
	// SumInFatBurnHeartZone: Active zone minutes in `HeartRateZone.FAT_BURN`.
	SumInFatBurnHeartZone int64 `json:"sumInFatBurnHeartZone,omitempty,string"`
	// SumInPeakHeartZone: Active zone minutes in `HeartRateZone.PEAK`.
	SumInPeakHeartZone int64 `json:"sumInPeakHeartZone,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "SumInCardioHeartZone") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "SumInCardioHeartZone") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActiveZoneMinutesRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod ActiveZoneMinutesRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityLevel: Internal type to capture activity level during a certain time
// interval.
type ActivityLevel struct {
	// ActivityLevelType: Required. Activity level type in the given time interval.
	//
	// Possible values:
	//   "ACTIVITY_LEVEL_TYPE_UNSPECIFIED" - Unspecified activity level type.
	//   "SEDENTARY" - Sedentary activity level.
	//   "LIGHTLY_ACTIVE" - Lightly active activity level.
	//   "MODERATELY_ACTIVE" - Moderately active activity level.
	//   "VERY_ACTIVE" - Very active activity level.
	ActivityLevelType string `json:"activityLevelType,omitempty"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActivityLevelType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActivityLevelType") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityLevel) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityLevel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityLevelRollupByActivityLevelType: Represents the total duration in a
// specific activity level type.
type ActivityLevelRollupByActivityLevelType struct {
	// ActivityLevelType: Activity level type.
	//
	// Possible values:
	//   "ACTIVITY_LEVEL_TYPE_UNSPECIFIED" - Unspecified activity level type.
	//   "SEDENTARY" - Sedentary activity level.
	//   "LIGHTLY_ACTIVE" - Lightly active activity level.
	//   "MODERATELY_ACTIVE" - Moderately active activity level.
	//   "VERY_ACTIVE" - Very active activity level.
	ActivityLevelType string `json:"activityLevelType,omitempty"`
	// TotalDuration: Total duration in the activity level type.
	TotalDuration string `json:"totalDuration,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActivityLevelType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActivityLevelType") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityLevelRollupByActivityLevelType) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityLevelRollupByActivityLevelType
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityLevelRollupValue: Represents the result of the rollup of the
// activity level data type.
type ActivityLevelRollupValue struct {
	// ActivityLevelRollupsByActivityLevelType: List of total durations in each
	// activity level type.
	ActivityLevelRollupsByActivityLevelType []*ActivityLevelRollupByActivityLevelType `json:"activityLevelRollupsByActivityLevelType,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "ActivityLevelRollupsByActivityLevelType") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "ActivityLevelRollupsByActivityLevelType") to include in API requests with
	// the JSON null value. By default, fields with empty values are omitted from
	// API requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields
	// for more details.
	NullFields []string `json:"-"`
}

func (s ActivityLevelRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityLevelRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AlertWindow: An analysis window evaluated for AFib. Note: The current
// version of the algorithm will only produce alerts if all windows are
// positive. So anything returned from the API will always have the positive
// bit set to true. Internally, windows can be negative, however. We never save
// "inconclusive" windows (they aren't produced by the algorithm).
type AlertWindow struct {
	// CivilEndTime: Output only. Observed interval end time in civil time in the
	// timezone the subject is in at the end of the observed interval
	CivilEndTime *CivilDateTime `json:"civilEndTime,omitempty"`
	// CivilStartTime: Output only. Observed interval start time in civil time in
	// the timezone the subject is in at the start of the observed interval
	CivilStartTime *CivilDateTime `json:"civilStartTime,omitempty"`
	// EndTime: Required. The end time of the analysis window.
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. The UTC offset of the user's timezone when the
	// analysis window ended.
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// HeartBeats: Optional. All heart beats in the interval contained in this
	// analysis window.
	HeartBeats []*HeartBeat `json:"heartBeats,omitempty"`
	// Positive: Optional. Flag indicating whether the window was positive for AFib
	// or not. A `true` value indicates that AFib was detected in this window. A
	// `false` value means AFib was not detected, but does not guarantee the
	// absence of AFib.
	Positive bool `json:"positive,omitempty"`
	// StartTime: Required. Observed interval. The start time of the analysis
	// window.
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. The UTC offset of the user's timezone when the
	// analysis window started.
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CivilEndTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CivilEndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AlertWindow) MarshalJSON() ([]byte, error) {
	type NoMethod AlertWindow
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Altitude: Captures the altitude gain (i.e. deltas), and not level above sea,
// for a user in millimeters.
type Altitude struct {
	// GainMillimeters: Required. Altitude gain in millimeters over the observed
	// interval.
	GainMillimeters int64 `json:"gainMillimeters,omitempty,string"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "GainMillimeters") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GainMillimeters") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Altitude) MarshalJSON() ([]byte, error) {
	type NoMethod Altitude
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AltitudeRollupValue: Represents the result of the rollup of the user's
// altitude.
type AltitudeRollupValue struct {
	// GainMillimetersSum: Sum of the altitude gain in millimeters.
	GainMillimetersSum int64 `json:"gainMillimetersSum,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "GainMillimetersSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GainMillimetersSum") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AltitudeRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod AltitudeRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Application: Optional metadata for the application that provided this data.
type Application struct {
	// GoogleWebClientId: Output only. The Google OAuth 2.0 client ID of the web
	// application or service that recorded the data. This is the client ID used
	// during the Google OAuth flow to obtain user credentials. This field is
	// system-populated when the data is uploaded from Google Web API.
	GoogleWebClientId string `json:"googleWebClientId,omitempty"`
	// PackageName: Output only. A unique identifier for the mobile application
	// that was the source of the data. This is typically the application's package
	// name on Android (e.g., `com.google.fitbit`) or the bundle ID on iOS. This
	// field is informational and helps trace data origin. This field is
	// system-populated when the data is uploaded from the Fitbit mobile
	// application, Health Connect or Health Kit.
	PackageName string `json:"packageName,omitempty"`
	// WebClientId: Output only. The client ID of the application that recorded the
	// data. This ID is a legacy Fitbit API client ID, which is different from a
	// Google OAuth client ID. Example format: `ABC123`. This field is
	// system-populated and used for tracing data from legacy Fitbit API
	// integrations. This field is system-populated when the data is uploaded from
	// a legacy Fitbit API integration.
	WebClientId string `json:"webClientId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "GoogleWebClientId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GoogleWebClientId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Application) MarshalJSON() ([]byte, error) {
	type NoMethod Application
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// BasalEnergyBurned: Number of calories burned due to basal metabolic rate
// (BMR) over a period of time.
type BasalEnergyBurned struct {
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// Kcal: Required. Number of calories burned due to basal metabolic rate in
	// kilocalories over the observed interval.
	Kcal float64 `json:"kcal,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BasalEnergyBurned) MarshalJSON() ([]byte, error) {
	type NoMethod BasalEnergyBurned
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *BasalEnergyBurned) UnmarshalJSON(data []byte) error {
	type NoMethod BasalEnergyBurned
	var s1 struct {
		Kcal gensupport.JSONFloat64 `json:"kcal"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Kcal = float64(s1.Kcal)
	return nil
}

// BatchDeleteDataPointsRequest: Request to delete a batch of identifiable data
// points.
type BatchDeleteDataPointsRequest struct {
	// Names: Required. The names of the DataPoints to delete. A maximum of 10000
	// data points can be deleted in a single request.
	Names []string `json:"names,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Names") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Names") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BatchDeleteDataPointsRequest) MarshalJSON() ([]byte, error) {
	type NoMethod BatchDeleteDataPointsRequest
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// BloodGlucose: Represents a blood glucose level measurement. LINT:
// LEGACY_NAMES
type BloodGlucose struct {
	// BloodGlucoseMilligramsPerDeciliter: Required. Blood glucose level
	// concentration in mg/dL.
	BloodGlucoseMilligramsPerDeciliter float64 `json:"bloodGlucoseMilligramsPerDeciliter,omitempty"`
	// MealType: Optional. Meal type of the measurement.
	//
	// Possible values:
	//   "MEAL_TYPE_UNSPECIFIED" - Unspecified meal type.
	//   "BREAKFAST" - Breakfast.
	//   "LUNCH" - Lunch.
	//   "DINNER" - Dinner.
	//   "SNACK" - Snack.
	MealType string `json:"mealType,omitempty"`
	// MeasurementSource: Optional. Source of the measurement.
	//
	// Possible values:
	//   "MEASUREMENT_SOURCE_UNSPECIFIED" - Unspecified measurement source.
	//   "SELF_MONITORING_BLOOD_GLUCOSE" - Self-monitoring of blood glucose (Blood
	// glucose meter)
	//   "CONTINUOUS_GLUCOSE_MONITORING" - Continuous glucose monitoring device
	//   "LAB_TEST" - Laboratory test
	MeasurementSource string `json:"measurementSource,omitempty"`
	// MeasurementTiming: Optional. Timing of the measurement.
	//
	// Possible values:
	//   "MEASUREMENT_TIMING_UNSPECIFIED" - Unspecified measurement timing.
	//   "AFTER_MEAL" - Measurement taken after meal.
	//   "BEFORE_MEAL" - Measurement taken before meal.
	//   "FASTING" - Measurement taken while fasting.
	//   "GENERAL" - General measurement (not associated with a meal or time of
	// day).
	//   "BEFORE_BED" - Measurement taken before bed.
	//   "OVER_NIGHT" - Measurement taken over night.
	MeasurementTiming string `json:"measurementTiming,omitempty"`
	// Notes: Optional. Standard free-form notes captured at manual logging.
	Notes string `json:"notes,omitempty"`
	// SampleTime: Required. The time at which blood glucose was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// Specimen: Optional. Type of body fluid used to measure the blood glucose.
	//
	// Possible values:
	//   "SPECIMEN_UNSPECIFIED" - Unspecified specimen.
	//   "CAPILLARY_BLOOD" - Capillary blood.
	//   "INTERSTITIAL_FLUID" - Interstitial fluid.
	//   "PLASMA" - Plasma.
	//   "SERUM" - Serum.
	//   "TEARS" - Tears.
	//   "WHOLE_BLOOD" - Whole blood.
	Specimen string `json:"specimen,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "BloodGlucoseMilligramsPerDeciliter") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "BloodGlucoseMilligramsPerDeciliter") to include in API requests with the
	// JSON null value. By default, fields with empty values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields for
	// more details.
	NullFields []string `json:"-"`
}

func (s BloodGlucose) MarshalJSON() ([]byte, error) {
	type NoMethod BloodGlucose
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *BloodGlucose) UnmarshalJSON(data []byte) error {
	type NoMethod BloodGlucose
	var s1 struct {
		BloodGlucoseMilligramsPerDeciliter gensupport.JSONFloat64 `json:"bloodGlucoseMilligramsPerDeciliter"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BloodGlucoseMilligramsPerDeciliter = float64(s1.BloodGlucoseMilligramsPerDeciliter)
	return nil
}

// BloodGlucoseRollupValue: Represents the result of the rollup of the blood
// glucose data type. LINT: LEGACY_NAMES
type BloodGlucoseRollupValue struct {
	// BloodGlucoseMilligramsPerDeciliterAvg: Average blood glucose level in mg/dL.
	BloodGlucoseMilligramsPerDeciliterAvg float64 `json:"bloodGlucoseMilligramsPerDeciliterAvg,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "BloodGlucoseMilligramsPerDeciliterAvg") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "BloodGlucoseMilligramsPerDeciliterAvg") to include in API requests with the
	// JSON null value. By default, fields with empty values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields for
	// more details.
	NullFields []string `json:"-"`
}

func (s BloodGlucoseRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod BloodGlucoseRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *BloodGlucoseRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod BloodGlucoseRollupValue
	var s1 struct {
		BloodGlucoseMilligramsPerDeciliterAvg gensupport.JSONFloat64 `json:"bloodGlucoseMilligramsPerDeciliterAvg"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BloodGlucoseMilligramsPerDeciliterAvg = float64(s1.BloodGlucoseMilligramsPerDeciliterAvg)
	return nil
}

// BodyFat: Body fat measurement.
type BodyFat struct {
	// Percentage: Required. Body fat percentage, in range [0, 100].
	Percentage float64 `json:"percentage,omitempty"`
	// SampleTime: Required. The time at which body fat was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Percentage") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Percentage") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BodyFat) MarshalJSON() ([]byte, error) {
	type NoMethod BodyFat
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *BodyFat) UnmarshalJSON(data []byte) error {
	type NoMethod BodyFat
	var s1 struct {
		Percentage gensupport.JSONFloat64 `json:"percentage"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Percentage = float64(s1.Percentage)
	return nil
}

// BodyFatRollupValue: Represents the result of the rollup of the body fat data
// type.
type BodyFatRollupValue struct {
	// BodyFatPercentageAvg: Average body fat percentage.
	BodyFatPercentageAvg float64 `json:"bodyFatPercentageAvg,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BodyFatPercentageAvg") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BodyFatPercentageAvg") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BodyFatRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod BodyFatRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *BodyFatRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod BodyFatRollupValue
	var s1 struct {
		BodyFatPercentageAvg gensupport.JSONFloat64 `json:"bodyFatPercentageAvg"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BodyFatPercentageAvg = float64(s1.BodyFatPercentageAvg)
	return nil
}

// CaloriesInHeartRateZoneRollupValue: Represents the result of the rollup of
// the calories in heart rate zone data type.
type CaloriesInHeartRateZoneRollupValue struct {
	// CaloriesInHeartRateZones: List of calories burned in each heart rate zone.
	CaloriesInHeartRateZones []*CaloriesInHeartRateZoneValue `json:"caloriesInHeartRateZones,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CaloriesInHeartRateZones")
	// to unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CaloriesInHeartRateZones") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CaloriesInHeartRateZoneRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod CaloriesInHeartRateZoneRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CaloriesInHeartRateZoneValue: Represents the amount of kilocalories burned
// in a specific heart rate zone.
type CaloriesInHeartRateZoneValue struct {
	// HeartRateZone: The heart rate zone.
	//
	// Possible values:
	//   "HEART_RATE_ZONE_TYPE_UNSPECIFIED" - Unspecified heart rate zone.
	//   "LIGHT" - The light heart rate zone.
	//   "MODERATE" - The moderate heart rate zone.
	//   "VIGOROUS" - The vigorous heart rate zone.
	//   "PEAK" - The peak heart rate zone.
	HeartRateZone string `json:"heartRateZone,omitempty"`
	// Kcal: The amount of kilocalories burned in the specified heart rate zone.
	Kcal float64 `json:"kcal,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HeartRateZone") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HeartRateZone") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CaloriesInHeartRateZoneValue) MarshalJSON() ([]byte, error) {
	type NoMethod CaloriesInHeartRateZoneValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *CaloriesInHeartRateZoneValue) UnmarshalJSON(data []byte) error {
	type NoMethod CaloriesInHeartRateZoneValue
	var s1 struct {
		Kcal gensupport.JSONFloat64 `json:"kcal"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Kcal = float64(s1.Kcal)
	return nil
}

// CivilDateTime: Civil time representation similar to google.type.DateTime,
// but ensures that neither the timezone nor the UTC offset can be set to avoid
// confusion between civil and physical time queries.
type CivilDateTime struct {
	// Date: Required. Calendar date.
	Date *Date `json:"date,omitempty"`
	// Time: Optional. Time of day. Defaults to the start of the day, at midnight
	// if omitted.
	Time *TimeOfDay `json:"time,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Date") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Date") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CivilDateTime) MarshalJSON() ([]byte, error) {
	type NoMethod CivilDateTime
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CivilTimeInterval: Counterpart of google.type.Interval, but using
// CivilDateTime.
type CivilTimeInterval struct {
	// End: Required. The exclusive end of the range.
	End *CivilDateTime `json:"end,omitempty"`
	// Start: Required. The inclusive start of the range.
	Start *CivilDateTime `json:"start,omitempty"`
	// ForceSendFields is a list of field names (e.g. "End") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "End") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CivilTimeInterval) MarshalJSON() ([]byte, error) {
	type NoMethod CivilTimeInterval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CoreBodyTemperature: Core body temperature measurement, distinct from
// peripheral body temperature, reflects the temperature of the body's internal
// organs.
type CoreBodyTemperature struct {
	// Id: Optional. The unique identifier of the core body temperature
	// measurement.
	Id string `json:"id,omitempty"`
	// MeasurementLocation: Optional. The location of the core body temperature
	// measurement.
	//
	// Possible values:
	//   "MEASUREMENT_LOCATION_UNSPECIFIED" - Measurement location is unspecified.
	//   "OTHER" - Other measurement location.
	//   "ARMPIT" - Armpit measurement location.
	//   "BODY" - Body measurement location.
	//   "EAR" - Ear measurement location.
	//   "FINGER" - Finger measurement location.
	//   "GASTRO_INTESTINAL" - Gastro-intestinal measurement location.
	//   "MOUTH" - Mouth measurement location.
	//   "RECTUM" - Rectum measurement location.
	//   "TOE" - Toe measurement location.
	//   "EAR_DRUM" - Ear drum measurement location.
	//   "TEMPORAL_ARTERY" - Temporal artery measurement location.
	//   "FOREHEAD" - Forehead measurement location.
	//   "URINARY_BLADDER" - Urinary bladder measurement location.
	//   "NASAL" - Nasal measurement location.
	//   "NASOPHARYNGEAL" - Nasopharyngeal measurement location.
	//   "WRIST" - Wrist measurement location.
	//   "VAGINA" - Vagina measurement location.
	MeasurementLocation string `json:"measurementLocation,omitempty"`
	// SampleTime: Required. The time at which core body temperature was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// TemperatureCelsius: Required. The core body temperature in Celsius.
	TemperatureCelsius float64 `json:"temperatureCelsius,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Id") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Id") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CoreBodyTemperature) MarshalJSON() ([]byte, error) {
	type NoMethod CoreBodyTemperature
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *CoreBodyTemperature) UnmarshalJSON(data []byte) error {
	type NoMethod CoreBodyTemperature
	var s1 struct {
		TemperatureCelsius gensupport.JSONFloat64 `json:"temperatureCelsius"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.TemperatureCelsius = float64(s1.TemperatureCelsius)
	return nil
}

// CoreBodyTemperatureRollupValue: Represents the result of the rollup of the
// core body temperature data type.
type CoreBodyTemperatureRollupValue struct {
	// TemperatureCelsiusAvg: Average core body temperature in Celsius.
	TemperatureCelsiusAvg float64 `json:"temperatureCelsiusAvg,omitempty"`
	// TemperatureCelsiusMax: Maximum core body temperature in Celsius.
	TemperatureCelsiusMax float64 `json:"temperatureCelsiusMax,omitempty"`
	// TemperatureCelsiusMin: Minimum core body temperature in Celsius.
	TemperatureCelsiusMin float64 `json:"temperatureCelsiusMin,omitempty"`
	// ForceSendFields is a list of field names (e.g. "TemperatureCelsiusAvg") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "TemperatureCelsiusAvg") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CoreBodyTemperatureRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod CoreBodyTemperatureRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *CoreBodyTemperatureRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod CoreBodyTemperatureRollupValue
	var s1 struct {
		TemperatureCelsiusAvg gensupport.JSONFloat64 `json:"temperatureCelsiusAvg"`
		TemperatureCelsiusMax gensupport.JSONFloat64 `json:"temperatureCelsiusMax"`
		TemperatureCelsiusMin gensupport.JSONFloat64 `json:"temperatureCelsiusMin"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.TemperatureCelsiusAvg = float64(s1.TemperatureCelsiusAvg)
	s.TemperatureCelsiusMax = float64(s1.TemperatureCelsiusMax)
	s.TemperatureCelsiusMin = float64(s1.TemperatureCelsiusMin)
	return nil
}

// CreateSubscriberPayload: Payload for creating a subscriber.
type CreateSubscriberPayload struct {
	// EndpointAuthorization: Required. Authorization mechanism for the subscriber
	// endpoint. The `secret` within this message is crucial for endpoint
	// verification and for securing webhook notifications.
	EndpointAuthorization *EndpointAuthorization `json:"endpointAuthorization,omitempty"`
	// EndpointUri: Required. The full HTTPS URI where update notifications will be
	// sent. The URI must be a valid URL and use HTTPS as the scheme. This endpoint
	// will be verified during the `CreateSubscriber` call. See CreateSubscriber
	// RPC documentation for verification details.
	EndpointUri string `json:"endpointUri,omitempty"`
	// SubscriberConfigs: Optional. Configuration for the subscriber.
	SubscriberConfigs []*SubscriberConfig `json:"subscriberConfigs,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EndpointAuthorization") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EndpointAuthorization") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CreateSubscriberPayload) MarshalJSON() ([]byte, error) {
	type NoMethod CreateSubscriberPayload
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CreateSubscriptionPayload: Payload for creating a subscription.
type CreateSubscriptionPayload struct {
	// DataTypes: Optional. Data types subscribed to.
	DataTypes []string `json:"dataTypes,omitempty"`
	// User: Required. Immutable. The resource name of the user for whom this
	// subscription is active. Format: `users/{user}` where `{user}` is the public
	// `healthUserId` as returned by the `GetIdentity` action in the profile PAPI
	// (see
	// `google.devicesandservices.health.v4main.HealthProfileService.GetIdentity`).
	User string `json:"user,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DataTypes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataTypes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CreateSubscriptionPayload) MarshalJSON() ([]byte, error) {
	type NoMethod CreateSubscriptionPayload
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyHeartRateVariability: Represents the daily heart rate variability data
// type. At least one of the following fields must be set: -
// `average_heart_rate_variability_milliseconds` -
// `non_rem_heart_rate_beats_per_minute` - `entropy` -
// `deep_sleep_root_mean_square_of_successive_differences_milliseconds`
type DailyHeartRateVariability struct {
	// AverageHeartRateVariabilityMilliseconds: Optional. A user's average heart
	// rate variability calculated using the root mean square of successive
	// differences (RMSSD) in times between heartbeats.
	AverageHeartRateVariabilityMilliseconds float64 `json:"averageHeartRateVariabilityMilliseconds,omitempty"`
	// Date: Required. Date (in the user's timezone) of heart rate variability
	// measurement.
	Date *Date `json:"date,omitempty"`
	// DeepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds: Optional. The
	// root mean square of successive differences (RMSSD) value during deep sleep.
	DeepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds float64 `json:"deepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds,omitempty"`
	// Entropy: Optional. The Shanon entropy of heartbeat intervals. Entropy
	// quantifies randomness or disorder in a system. High entropy indicates high
	// HRV. Entropy is measured from the histogram of time interval between
	// successive heart beats values measured during sleep.
	Entropy float64 `json:"entropy,omitempty"`
	// NonRemHeartRateBeatsPerMinute: Optional. Non-REM heart rate
	NonRemHeartRateBeatsPerMinute int64 `json:"nonRemHeartRateBeatsPerMinute,omitempty,string"`
	// ForceSendFields is a list of field names (e.g.
	// "AverageHeartRateVariabilityMilliseconds") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "AverageHeartRateVariabilityMilliseconds") to include in API requests with
	// the JSON null value. By default, fields with empty values are omitted from
	// API requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields
	// for more details.
	NullFields []string `json:"-"`
}

func (s DailyHeartRateVariability) MarshalJSON() ([]byte, error) {
	type NoMethod DailyHeartRateVariability
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *DailyHeartRateVariability) UnmarshalJSON(data []byte) error {
	type NoMethod DailyHeartRateVariability
	var s1 struct {
		AverageHeartRateVariabilityMilliseconds                    gensupport.JSONFloat64 `json:"averageHeartRateVariabilityMilliseconds"`
		DeepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds gensupport.JSONFloat64 `json:"deepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds"`
		Entropy                                                    gensupport.JSONFloat64 `json:"entropy"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AverageHeartRateVariabilityMilliseconds = float64(s1.AverageHeartRateVariabilityMilliseconds)
	s.DeepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds = float64(s1.DeepSleepRootMeanSquareOfSuccessiveDifferencesMilliseconds)
	s.Entropy = float64(s1.Entropy)
	return nil
}

// DailyHeartRateZones: User's heart rate zone thresholds based on the Karvonen
// algorithm for a specific day.
type DailyHeartRateZones struct {
	// Date: Required. Date (in user's timezone) of the heart rate zones record.
	Date *Date `json:"date,omitempty"`
	// HeartRateZones: Required. The heart rate zones.
	HeartRateZones []*HeartRateZone `json:"heartRateZones,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Date") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Date") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyHeartRateZones) MarshalJSON() ([]byte, error) {
	type NoMethod DailyHeartRateZones
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyOxygenSaturation: A daily oxygen saturation (SpO2) record. Represents
// the user's daily oxygen saturation summary, typically calculated during
// sleep.
type DailyOxygenSaturation struct {
	// AveragePercentage: Required. The average value of the oxygen saturation
	// samples during the sleep.
	AveragePercentage float64 `json:"averagePercentage,omitempty"`
	// Date: Required. Date (in user's timezone) of the daily oxygen saturation
	// record.
	Date *Date `json:"date,omitempty"`
	// LowerBoundPercentage: Required. The lower bound of the confidence interval
	// of oxygen saturation samples during sleep.
	LowerBoundPercentage float64 `json:"lowerBoundPercentage,omitempty"`
	// StandardDeviationPercentage: Optional. Standard deviation of the daily
	// oxygen saturation averages from the past 7-30 days.
	StandardDeviationPercentage float64 `json:"standardDeviationPercentage,omitempty"`
	// UpperBoundPercentage: Required. The upper bound of the confidence interval
	// of oxygen saturation samples during sleep.
	UpperBoundPercentage float64 `json:"upperBoundPercentage,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AveragePercentage") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AveragePercentage") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyOxygenSaturation) MarshalJSON() ([]byte, error) {
	type NoMethod DailyOxygenSaturation
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *DailyOxygenSaturation) UnmarshalJSON(data []byte) error {
	type NoMethod DailyOxygenSaturation
	var s1 struct {
		AveragePercentage           gensupport.JSONFloat64 `json:"averagePercentage"`
		LowerBoundPercentage        gensupport.JSONFloat64 `json:"lowerBoundPercentage"`
		StandardDeviationPercentage gensupport.JSONFloat64 `json:"standardDeviationPercentage"`
		UpperBoundPercentage        gensupport.JSONFloat64 `json:"upperBoundPercentage"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AveragePercentage = float64(s1.AveragePercentage)
	s.LowerBoundPercentage = float64(s1.LowerBoundPercentage)
	s.StandardDeviationPercentage = float64(s1.StandardDeviationPercentage)
	s.UpperBoundPercentage = float64(s1.UpperBoundPercentage)
	return nil
}

// DailyRespiratoryRate: A daily average respiratory rate (breaths per minute)
// for a day of the year. One data point per day calculated for the main sleep.
type DailyRespiratoryRate struct {
	// BreathsPerMinute: Required. The average number of breaths taken per minute.
	BreathsPerMinute float64 `json:"breathsPerMinute,omitempty"`
	// Date: Required. The date on which the respiratory rate was measured.
	Date *Date `json:"date,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BreathsPerMinute") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BreathsPerMinute") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRespiratoryRate) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRespiratoryRate
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *DailyRespiratoryRate) UnmarshalJSON(data []byte) error {
	type NoMethod DailyRespiratoryRate
	var s1 struct {
		BreathsPerMinute gensupport.JSONFloat64 `json:"breathsPerMinute"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BreathsPerMinute = float64(s1.BreathsPerMinute)
	return nil
}

// DailyRestingHeartRate: Measures the daily resting heart rate for a user,
// calculated using the all day heart rate measurements.
type DailyRestingHeartRate struct {
	// BeatsPerMinute: Required. The resting heart rate value in beats per minute.
	BeatsPerMinute int64 `json:"beatsPerMinute,omitempty,string"`
	// DailyRestingHeartRateMetadata: Optional. Metadata for the daily resting
	// heart rate.
	DailyRestingHeartRateMetadata *DailyRestingHeartRateMetadata `json:"dailyRestingHeartRateMetadata,omitempty"`
	// Date: Required. Date (in the user's timezone) of the resting heart rate
	// measurement.
	Date *Date `json:"date,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinute") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinute") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRestingHeartRate) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRestingHeartRate
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyRestingHeartRateMetadata: Metadata for the daily resting heart rate.
type DailyRestingHeartRateMetadata struct {
	// CalculationMethod: Required. The method used to calculate the resting heart
	// rate.
	//
	// Possible values:
	//   "CALCULATION_METHOD_UNSPECIFIED" - The calculation method is unspecified.
	//   "WITH_SLEEP" - The resting heart rate is calculated using the sleep data.
	//   "ONLY_WITH_AWAKE_DATA" - The resting heart rate is calculated using only
	// awake data.
	CalculationMethod string `json:"calculationMethod,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CalculationMethod") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CalculationMethod") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRestingHeartRateMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRestingHeartRateMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyRollUpDataPointsRequest: Request to roll up data points by civil time
// intervals.
type DailyRollUpDataPointsRequest struct {
	// DataSourceFamily: Optional. The data source family name to roll up. If
	// empty, data points from all available data sources will be rolled up.
	// Format: `users/me/dataSourceFamilies/{data_source_family}` The supported
	// values are: - `users/me/dataSourceFamilies/all-sources` - Default value.
	// Includes data from all available data sources. -
	// `users/me/dataSourceFamilies/google-wearables` - Includes data from Google
	// and Fitbit tracker devices (such as Fitbit trackers and Pixel Watch).
	// Excludes manually logged data. -
	// `users/me/dataSourceFamilies/google-sources` - Includes first-party Google
	// data, such as data from tracker devices, manually logged data, and Health
	// Connect.
	DataSourceFamily string `json:"dataSourceFamily,omitempty"`
	// PageSize: Optional. The maximum number of data points to return. If
	// unspecified, at most 1440 data points will be returned. The maximum page
	// size is 10000; values above that will be truncated accordingly.
	PageSize int64 `json:"pageSize,omitempty"`
	// PageToken: Optional. The `next_page_token` from a previous request, if any.
	// All other request fields need to be the same as in the initial request when
	// the page token is specified.
	PageToken string `json:"pageToken,omitempty"`
	// Range: Required. Closed-open range of data points that will be rolled up.
	// The start time must be aligned with the aggregation window. The maximum
	// range for `calories-in-heart-rate-zone`, `heart-rate`, `active-minutes` and
	// `total-calories` is 14 days. The maximum range for all other data types is
	// 90 days.
	Range *CivilTimeInterval `json:"range,omitempty"`
	// WindowSizeDays: Optional. Aggregation window size, in number of days.
	// Defaults to 1 if not specified. If the requested range is not an exact
	// multiple of `window_size_days`, the final bucket chronologically will be
	// truncated at the upper endpoint of the range and will cover a duration
	// shorter than `window_size_days`.
	WindowSizeDays int64 `json:"windowSizeDays,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DataSourceFamily") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataSourceFamily") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRollUpDataPointsRequest) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRollUpDataPointsRequest
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyRollUpDataPointsResponse: Response containing the list of rolled up
// data points.
type DailyRollUpDataPointsResponse struct {
	// RollupDataPoints: Values for each aggregation time window.
	RollupDataPoints []*DailyRollupDataPoint `json:"rollupDataPoints,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "RollupDataPoints") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RollupDataPoints") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRollUpDataPointsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRollUpDataPointsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailyRollupDataPoint: Value of a daily rollup for a single civil time
// interval (aggregation window) of reconciled data points from all data
// sources, excluding those data points that are identified as recorded by
// wearables in intervals when they were not actually worn.
type DailyRollupDataPoint struct {
	// ActiveEnergyBurned: Returned by default when rolling up data points from the
	// `active-energy-burned` data type.
	ActiveEnergyBurned *ActiveEnergyBurnedRollupValue `json:"activeEnergyBurned,omitempty"`
	// ActiveMinutes: Returned by default when rolling up data points from the
	// `active-minutes` data type, or when requested explicitly using the
	// `active-minutes` rollup type identifier.
	ActiveMinutes *ActiveMinutesRollupValue `json:"activeMinutes,omitempty"`
	// ActiveZoneMinutes: Returned by default when rolling up data points from the
	// `active-zone-minutes` data type, or when requested explicitly using the
	// `active-zone-minutes` rollup type identifier.
	ActiveZoneMinutes *ActiveZoneMinutesRollupValue `json:"activeZoneMinutes,omitempty"`
	// ActivityLevel: Returned by default when rolling up data points from the
	// `activity-level` data type, or when requested explicitly using the
	// `activity-level` rollup type identifier.
	ActivityLevel *ActivityLevelRollupValue `json:"activityLevel,omitempty"`
	// Altitude: Returned by default when rolling up data points from the
	// `altitude` data type, or when requested explicitly using the `altitude`
	// rollup type identifier.
	Altitude *AltitudeRollupValue `json:"altitude,omitempty"`
	// BloodGlucose: Returned by default when rolling up data points from the
	// `blood-glucose` data type.
	BloodGlucose *BloodGlucoseRollupValue `json:"bloodGlucose,omitempty"`
	// BodyFat: Returned by default when rolling up data points from the `body-fat`
	// data type, or when requested explicitly using the `body-fat` rollup type
	// identifier.
	BodyFat *BodyFatRollupValue `json:"bodyFat,omitempty"`
	// CaloriesInHeartRateZone: Returned by default when rolling up data points
	// from the `calories-in-heart-rate-zone` data type, or when requested
	// explicitly using the `calories-in-heart-rate-zone` rollup type identifier.
	CaloriesInHeartRateZone *CaloriesInHeartRateZoneRollupValue `json:"caloriesInHeartRateZone,omitempty"`
	// CivilEndTime: End time of the window this value aggregates over
	CivilEndTime *CivilDateTime `json:"civilEndTime,omitempty"`
	// CivilStartTime: Start time of the window this value aggregates over
	CivilStartTime *CivilDateTime `json:"civilStartTime,omitempty"`
	// CoreBodyTemperature: Returned by default when rolling up data points from
	// the `core-body-temperature` data type, or when requested explicitly using
	// the `core-body-temperature` rollup type identifier.
	CoreBodyTemperature *CoreBodyTemperatureRollupValue `json:"coreBodyTemperature,omitempty"`
	// Distance: Returned by default when rolling up data points from the
	// `distance` data type, or when requested explicitly using the `distance`
	// rollup type identifier.
	Distance *DistanceRollupValue `json:"distance,omitempty"`
	// Floors: Returned by default when rolling up data points from the `floors`
	// data type, or when requested explicitly using the `floors` rollup type
	// identifier.
	Floors *FloorsRollupValue `json:"floors,omitempty"`
	// HeartRate: Returned by default when rolling up data points from the
	// `heart-rate` data type, or when requested explicitly using the `heart-rate`
	// rollup type identifier.
	HeartRate *HeartRateRollupValue `json:"heartRate,omitempty"`
	// HeartRateVariabilityPersonalRange: Returned by default when rolling up data
	// points from the `daily-heart-rate-variability` data type, or when requested
	// explicitly using the `heart-rate-variability-personal-range` rollup type
	// identifier.
	HeartRateVariabilityPersonalRange *HeartRateVariabilityPersonalRangeRollupValue `json:"heartRateVariabilityPersonalRange,omitempty"`
	// HydrationLog: Returned by default when rolling up data points from the
	// `hydration-log` data type, or when requested explicitly using the
	// `hydration-log` rollup type identifier.
	HydrationLog *HydrationLogRollupValue `json:"hydrationLog,omitempty"`
	// NutritionLog: Returned by default when rolling up data points from the
	// `nutrition-log` data type, or when requested explicitly using the
	// `nutrition-log` rollup type identifier.
	NutritionLog *NutritionLogRollupValue `json:"nutritionLog,omitempty"`
	// RestingHeartRatePersonalRange: Returned by default when rolling up data
	// points from the `daily-resting-heart-rate` data type, or when requested
	// explicitly using the `resting-heart-rate-personal-range` rollup type
	// identifier.
	RestingHeartRatePersonalRange *RestingHeartRatePersonalRangeRollupValue `json:"restingHeartRatePersonalRange,omitempty"`
	// RunVo2Max: Returned by default when rolling up data points from the
	// `run-vo2-max` data type, or when requested explicitly using the
	// `run-vo2-max` rollup type identifier.
	RunVo2Max *RunVO2MaxRollupValue `json:"runVo2Max,omitempty"`
	// SedentaryPeriod: Returned by default when rolling up data points from the
	// `sedentary-period` data type, or when requested explicitly using the
	// `sedentary-period` rollup type identifier.
	SedentaryPeriod *SedentaryPeriodRollupValue `json:"sedentaryPeriod,omitempty"`
	// Steps: Returned by default when rolling up data points from the `steps` data
	// type, or when requested explicitly using the `steps` rollup type identifier.
	Steps *StepsRollupValue `json:"steps,omitempty"`
	// SwimLengthsData: Returned by default when rolling up data points from the
	// `swim-lengths-data` data type, or when requested explicitly using the
	// `swim-lengths-data` rollup type identifier.
	SwimLengthsData *SwimLengthsDataRollupValue `json:"swimLengthsData,omitempty"`
	// TimeInHeartRateZone: Returned by default when rolling up data points from
	// the `time-in-heart-rate-zone` data type, or when requested explicitly using
	// the `time-in-heart-rate-zone` rollup type identifier.
	TimeInHeartRateZone *TimeInHeartRateZoneRollupValue `json:"timeInHeartRateZone,omitempty"`
	// TotalCalories: Returned by default when rolling up data points from the
	// `total-calories` data type, or when requested explicitly using the
	// `total-calories` rollup type identifier.
	TotalCalories *TotalCaloriesRollupValue `json:"totalCalories,omitempty"`
	// Weight: Returned by default when rolling up data points from the `weight`
	// data type, or when requested explicitly using the `weight` rollup type
	// identifier.
	Weight *WeightRollupValue `json:"weight,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveEnergyBurned") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveEnergyBurned") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyRollupDataPoint) MarshalJSON() ([]byte, error) {
	type NoMethod DailyRollupDataPoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DailySleepTemperatureDerivations: Provides derived sleep temperature values,
// calculated from skin or internal device temperature readings during sleep.
type DailySleepTemperatureDerivations struct {
	// BaselineTemperatureCelsius: Optional. The user's baseline skin temperature.
	// It is the median of the user's nightly skin temperature over the past 30
	// days.
	BaselineTemperatureCelsius float64 `json:"baselineTemperatureCelsius,omitempty"`
	// Date: Required. Date for which the sleep temperature derivations are
	// calculated.
	Date *Date `json:"date,omitempty"`
	// NightlyTemperatureCelsius: Required. The user's nightly skin temperature. It
	// is the mean of skin temperature samples taken from the user’s sleep.
	NightlyTemperatureCelsius float64 `json:"nightlyTemperatureCelsius,omitempty"`
	// RelativeNightlyStddev30dCelsius: Optional. The standard deviation of the
	// user’s relative nightly skin temperature (temperature - baseline) over the
	// past 30 days.
	RelativeNightlyStddev30dCelsius float64 `json:"relativeNightlyStddev30dCelsius,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BaselineTemperatureCelsius")
	// to unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BaselineTemperatureCelsius") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailySleepTemperatureDerivations) MarshalJSON() ([]byte, error) {
	type NoMethod DailySleepTemperatureDerivations
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *DailySleepTemperatureDerivations) UnmarshalJSON(data []byte) error {
	type NoMethod DailySleepTemperatureDerivations
	var s1 struct {
		BaselineTemperatureCelsius      gensupport.JSONFloat64 `json:"baselineTemperatureCelsius"`
		NightlyTemperatureCelsius       gensupport.JSONFloat64 `json:"nightlyTemperatureCelsius"`
		RelativeNightlyStddev30dCelsius gensupport.JSONFloat64 `json:"relativeNightlyStddev30dCelsius"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BaselineTemperatureCelsius = float64(s1.BaselineTemperatureCelsius)
	s.NightlyTemperatureCelsius = float64(s1.NightlyTemperatureCelsius)
	s.RelativeNightlyStddev30dCelsius = float64(s1.RelativeNightlyStddev30dCelsius)
	return nil
}

// DailyVO2Max: Contains a daily summary of the user's VO2 max (cardio fitness
// score), which is the maximum rate of oxygen the body can use during
// exercise.
type DailyVO2Max struct {
	// CardioFitnessLevel: Optional. Represents the user's cardio fitness level
	// based on their VO2 max.
	//
	// Possible values:
	//   "CARDIO_FITNESS_LEVEL_UNSPECIFIED" - Unspecified cardio fitness level.
	//   "POOR" - Poor cardio fitness level.
	//   "FAIR" - Fair cardio fitness level.
	//   "AVERAGE" - Average cardio fitness level.
	//   "GOOD" - Good cardio fitness level.
	//   "VERY_GOOD" - Very good cardio fitness level.
	//   "EXCELLENT" - Excellent cardio fitness level.
	CardioFitnessLevel string `json:"cardioFitnessLevel,omitempty"`
	// Date: Required. The date for which the Daily VO2 max was measured.
	Date *Date `json:"date,omitempty"`
	// Estimated: Optional. An estimated field is added to indicate when the
	// confidence has decreased sufficiently to consider the value an estimation.
	Estimated bool `json:"estimated,omitempty"`
	// Vo2Max: Required. Daily VO2 max value measured as in ml consumed oxygen / kg
	// of body weight / min.
	Vo2Max float64 `json:"vo2Max,omitempty"`
	// Vo2MaxCovariance: Optional. The covariance of the VO2 max value.
	Vo2MaxCovariance float64 `json:"vo2MaxCovariance,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CardioFitnessLevel") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CardioFitnessLevel") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DailyVO2Max) MarshalJSON() ([]byte, error) {
	type NoMethod DailyVO2Max
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *DailyVO2Max) UnmarshalJSON(data []byte) error {
	type NoMethod DailyVO2Max
	var s1 struct {
		Vo2Max           gensupport.JSONFloat64 `json:"vo2Max"`
		Vo2MaxCovariance gensupport.JSONFloat64 `json:"vo2MaxCovariance"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Vo2Max = float64(s1.Vo2Max)
	s.Vo2MaxCovariance = float64(s1.Vo2MaxCovariance)
	return nil
}

// DataPoint: A computed or recorded metric.
type DataPoint struct {
	// ActiveEnergyBurned: Optional. Data for points in the `active-energy-burned`
	// interval data type collection.
	ActiveEnergyBurned *ActiveEnergyBurned `json:"activeEnergyBurned,omitempty"`
	// ActiveMinutes: Optional. Data for points in the `active-minutes` interval
	// data type collection.
	ActiveMinutes *ActiveMinutes `json:"activeMinutes,omitempty"`
	// ActiveZoneMinutes: Optional. Data for points in the `active-zone-minutes`
	// interval data type collection, measured in minutes.
	ActiveZoneMinutes *ActiveZoneMinutes `json:"activeZoneMinutes,omitempty"`
	// ActivityLevel: Optional. Data for points in the `activity-level` daily data
	// type collection.
	ActivityLevel *ActivityLevel `json:"activityLevel,omitempty"`
	// Altitude: Optional. Data for points in the `altitude` interval data type
	// collection.
	Altitude *Altitude `json:"altitude,omitempty"`
	// BasalEnergyBurned: Optional. Data for points in the `basal-energy-burned`
	// interval data type collection.
	BasalEnergyBurned *BasalEnergyBurned `json:"basalEnergyBurned,omitempty"`
	// BloodGlucose: Optional. Data for points in the `blood-glucose` sample data
	// type collection.
	BloodGlucose *BloodGlucose `json:"bloodGlucose,omitempty"`
	// BodyFat: Optional. Data for points in the `body-fat` sample data type
	// collection.
	BodyFat *BodyFat `json:"bodyFat,omitempty"`
	// CoreBodyTemperature: Optional. Data for points in the
	// `core-body-temperature` sample data type collection.
	CoreBodyTemperature *CoreBodyTemperature `json:"coreBodyTemperature,omitempty"`
	// DailyHeartRateVariability: Optional. Data for points in the
	// `daily-heart-rate-variability` daily data type collection.
	DailyHeartRateVariability *DailyHeartRateVariability `json:"dailyHeartRateVariability,omitempty"`
	// DailyHeartRateZones: Optional. Data for points in the
	// `daily-heart-rate-zones` daily data type collection.
	DailyHeartRateZones *DailyHeartRateZones `json:"dailyHeartRateZones,omitempty"`
	// DailyOxygenSaturation: Optional. Data for points in the
	// `daily-oxygen-saturation` daily data type collection.
	DailyOxygenSaturation *DailyOxygenSaturation `json:"dailyOxygenSaturation,omitempty"`
	// DailyRespiratoryRate: Optional. Data for points in the
	// `daily-respiratory-rate` daily data type collection.
	DailyRespiratoryRate *DailyRespiratoryRate `json:"dailyRespiratoryRate,omitempty"`
	// DailyRestingHeartRate: Optional. Data for points in the
	// `daily-resting-heart-rate` daily data type collection.
	DailyRestingHeartRate *DailyRestingHeartRate `json:"dailyRestingHeartRate,omitempty"`
	// DailySleepTemperatureDerivations: Optional. Data for points in the
	// `daily-sleep-temperature-derivations` daily data type collection.
	DailySleepTemperatureDerivations *DailySleepTemperatureDerivations `json:"dailySleepTemperatureDerivations,omitempty"`
	// DailyVo2Max: Optional. Data for points in the `daily-vo2-max` daily data
	// type collection.
	DailyVo2Max *DailyVO2Max `json:"dailyVo2Max,omitempty"`
	// DataSource: Optional. Data source information for the metric
	DataSource *DataSource `json:"dataSource,omitempty"`
	// Distance: Optional. Data for points in the `distance` interval data type
	// collection.
	Distance *Distance `json:"distance,omitempty"`
	// Electrocardiogram: Optional. Data for points in the `electrocardiogram`
	// session data type collection.
	Electrocardiogram *Electrocardiogram `json:"electrocardiogram,omitempty"`
	// Exercise: Optional. Data for points in the `exercise` session data type
	// collection.
	Exercise *Exercise `json:"exercise,omitempty"`
	// Floors: Optional. Data for points in the `floors` interval data type
	// collection.
	Floors *Floors `json:"floors,omitempty"`
	// Food: Optional. The food details.
	Food *Food `json:"food,omitempty"`
	// FoodMeasurementUnit: Optional. The food measurement unit details.
	FoodMeasurementUnit *FoodMeasurementUnit `json:"foodMeasurementUnit,omitempty"`
	// HeartRate: Optional. Data for points in the `heart-rate` sample data type
	// collection.
	HeartRate *HeartRate `json:"heartRate,omitempty"`
	// HeartRateVariability: Optional. Data for points in the
	// `heart-rate-variability` sample data type collection.
	HeartRateVariability *HeartRateVariability `json:"heartRateVariability,omitempty"`
	// Height: Optional. Data for points in the `height` sample data type
	// collection.
	Height *Height `json:"height,omitempty"`
	// HydrationLog: Optional. Data for points in the `hydration-log` session data
	// type collection.
	HydrationLog *HydrationLog `json:"hydrationLog,omitempty"`
	// IrregularRhythmNotification: Optional. Data for points in the
	// `irregular-rhythm-notification` session data type collection.
	IrregularRhythmNotification *IrregularRhythmNotification `json:"irregularRhythmNotification,omitempty"`
	// MenstrualPeriod: Optional. Data for points in the `menstrual-period`
	// interval data type collection.
	MenstrualPeriod *MenstrualPeriod `json:"menstrualPeriod,omitempty"`
	// Moods: Optional. Data for points in the `moods` sample data type collection.
	Moods *Moods `json:"moods,omitempty"`
	// Name: Identifier. Data point name, only supported for the subset of
	// identifiable data types. For the majority of the data types, individual data
	// points do not need to be identified and this field would be empty. Format:
	// `users/{user}/dataTypes/{data_type}/dataPoints/{data_point}` Example:
	// `users/abcd1234/dataTypes/sleep/dataPoints/a1b2c3d4-e5f6-7890-1234-567890abcd
	// ef` The `{user}` ID is a system-generated identifier, as described in
	// Identity.health_user_id. The `{data_type}` ID corresponds to the kebab-case
	// version of the field names in the DataPoint data union field, e.g.
	// `heart-rate` for the `heart_rate` field. The `{data_point}` ID can be
	// client-provided or system-generated. If client-provided, it must be a string
	// of 4-63 characters, containing only lowercase letters, numbers, and hyphens.
	Name string `json:"name,omitempty"`
	// NutritionLog: Optional. Data for points in the `nutrition-log` session data
	// type collection.
	NutritionLog *NutritionLog `json:"nutritionLog,omitempty"`
	// OvulationTest: Optional. Data for points in the `ovulation-test` sample data
	// type collection.
	OvulationTest *OvulationTest `json:"ovulationTest,omitempty"`
	// OxygenSaturation: Optional. Data for points in the `oxygen-saturation`
	// sample data type collection.
	OxygenSaturation *OxygenSaturation `json:"oxygenSaturation,omitempty"`
	// RespiratoryRateSleepSummary: Optional. Data for points in the
	// `respiratory-rate-sleep-summary` sample data type collection.
	RespiratoryRateSleepSummary *RespiratoryRateSleepSummary `json:"respiratoryRateSleepSummary,omitempty"`
	// RunVo2Max: Optional. Data for points in the `run-vo2-max` sample data type
	// collection.
	RunVo2Max *RunVO2Max `json:"runVo2Max,omitempty"`
	// SedentaryPeriod: Optional. Data for points in the `sedentary-period`
	// interval data type collection.
	SedentaryPeriod *SedentaryPeriod `json:"sedentaryPeriod,omitempty"`
	// Sleep: Optional. Data for points in the `sleep` session data type
	// collection.
	Sleep *Sleep `json:"sleep,omitempty"`
	// Steps: Optional. Data for points in the `steps` interval data type
	// collection.
	Steps *Steps `json:"steps,omitempty"`
	// SwimLengthsData: Optional. Data for points in the `swim-lengths-data`
	// interval data type collection.
	SwimLengthsData *SwimLengthsData `json:"swimLengthsData,omitempty"`
	// Symptoms: Optional. Data for points in the `symptoms` sample data type
	// collection.
	Symptoms *Symptoms `json:"symptoms,omitempty"`
	// TimeInHeartRateZone: Optional. Data for points in the
	// `time-in-heart-rate-zone` interval data type collection.
	TimeInHeartRateZone *TimeInHeartRateZone `json:"timeInHeartRateZone,omitempty"`
	// Vo2Max: Optional. Data for points in the `vo2-max` sample data type
	// collection.
	Vo2Max *VO2Max `json:"vo2Max,omitempty"`
	// Weight: Optional. Data for points in the `weight` sample data type
	// collection.
	Weight *Weight `json:"weight,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "ActiveEnergyBurned") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveEnergyBurned") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DataPoint) MarshalJSON() ([]byte, error) {
	type NoMethod DataPoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DataSource: Data Source definition to track the origin of data. Each health
// data point, regardless of the complexity or data model (whether a simple
// step count or a detailed sleep session) must retain information about its
// source of origin (e.g. the device or app that collected it).
type DataSource struct {
	// Application: Output only. Captures metadata for the application that
	// provided this data.
	Application *Application `json:"application,omitempty"`
	// Device: Optional. Captures metadata for raw data points originating from
	// devices. We expect this data source to be used for data points written on
	// device sync.
	Device *Device `json:"device,omitempty"`
	// Platform: Output only. Captures the platform that uploaded the data.
	//
	// Possible values:
	//   "PLATFORM_UNSPECIFIED" - The platform is unspecified.
	//   "FITBIT" - The data was uploaded from Fitbit.
	//   "HEALTH_CONNECT" - The data was uploaded from Health Connect.
	//   "HEALTH_KIT" - The data was uploaded from Health Kit.
	//   "FIT" - The data was uploaded from Google Fit.
	//   "FITBIT_WEB_API" - The data was uploaded from Fitbit legacy Web API.
	//   "NEST" - The data was uploaded from Nest devices.
	//   "GOOGLE_WEB_API" - The data was uploaded from Google Health API.
	//   "GOOGLE_PARTNER_INTEGRATION" - The data was uploaded from Google Partner
	// Integrations.
	Platform string `json:"platform,omitempty"`
	// RecordingMethod: Optional. Captures how the data was recorded.
	//
	// Possible values:
	//   "RECORDING_METHOD_UNSPECIFIED" - The recording method is unspecified.
	//   "MANUAL" - The data was manually entered by the user.
	//   "PASSIVELY_MEASURED" - The data was passively measured by a device.
	//   "DERIVED" - The data was derived from other data, e.g., by an algorithm in
	// the backend.
	//   "ACTIVELY_MEASURED" - The data was actively measured by a device.
	//   "UNKNOWN" - The recording method is unknown. This is set when the data is
	// uploaded from a third party app that does not provide this information.
	RecordingMethod string `json:"recordingMethod,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Application") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Application") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DataSource) MarshalJSON() ([]byte, error) {
	type NoMethod DataSource
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Date: Represents a whole or partial calendar date, such as a birthday. The
// time of day and time zone are either specified elsewhere or are
// insignificant. The date is relative to the Gregorian Calendar. This can
// represent one of the following: * A full date, with non-zero year, month,
// and day values. * A month and day, with a zero year (for example, an
// anniversary). * A year on its own, with a zero month and a zero day. * A
// year and month, with a zero day (for example, a credit card expiration
// date). Related types: * google.type.TimeOfDay * google.type.DateTime *
// google.protobuf.Timestamp
type Date struct {
	// Day: Day of a month. Must be from 1 to 31 and valid for the year and month,
	// or 0 to specify a year by itself or a year and month where the day isn't
	// significant.
	Day int64 `json:"day,omitempty"`
	// Month: Month of a year. Must be from 1 to 12, or 0 to specify a year without
	// a month and day.
	Month int64 `json:"month,omitempty"`
	// Year: Year of the date. Must be from 1 to 9999, or 0 to specify a date
	// without a year.
	Year int64 `json:"year,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Day") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Day") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Date) MarshalJSON() ([]byte, error) {
	type NoMethod Date
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DateTime: Represents civil time (or occasionally physical time). This type
// can represent a civil time in one of a few possible ways: * When utc_offset
// is set and time_zone is unset: a civil time on a calendar day with a
// particular offset from UTC. * When time_zone is set and utc_offset is unset:
// a civil time on a calendar day in a particular time zone. * When neither
// time_zone nor utc_offset is set: a civil time on a calendar day in local
// time. The date is relative to the Proleptic Gregorian Calendar. If year,
// month, or day are 0, the DateTime is considered not to have a specific year,
// month, or day respectively. This type may also be used to represent a
// physical time if all the date and time fields are set and either case of the
// `time_offset` oneof is set. Consider using `Timestamp` message for physical
// time instead. If your use case also would like to store the user's timezone,
// that can be done in another field. This type is more flexible than some
// applications may want. Make sure to document and validate your application's
// limitations.
type DateTime struct {
	// Day: Optional. Day of month. Must be from 1 to 31 and valid for the year and
	// month, or 0 if specifying a datetime without a day.
	Day int64 `json:"day,omitempty"`
	// Hours: Optional. Hours of day in 24 hour format. Should be from 0 to 23,
	// defaults to 0 (midnight). An API may choose to allow the value "24:00:00"
	// for scenarios like business closing time.
	Hours int64 `json:"hours,omitempty"`
	// Minutes: Optional. Minutes of hour of day. Must be from 0 to 59, defaults to
	// 0.
	Minutes int64 `json:"minutes,omitempty"`
	// Month: Optional. Month of year. Must be from 1 to 12, or 0 if specifying a
	// datetime without a month.
	Month int64 `json:"month,omitempty"`
	// Nanos: Optional. Fractions of seconds in nanoseconds. Must be from 0 to
	// 999,999,999, defaults to 0.
	Nanos int64 `json:"nanos,omitempty"`
	// Seconds: Optional. Seconds of minutes of the time. Must normally be from 0
	// to 59, defaults to 0. An API may allow the value 60 if it allows
	// leap-seconds.
	Seconds int64 `json:"seconds,omitempty"`
	// TimeZone: Time zone.
	TimeZone *TimeZone `json:"timeZone,omitempty"`
	// UtcOffset: UTC offset. Must be whole seconds, between -18 hours and +18
	// hours. For example, a UTC offset of -4:00 would be represented as { seconds:
	// -14400 }.
	UtcOffset string `json:"utcOffset,omitempty"`
	// Year: Optional. Year of date. Must be from 1 to 9999, or 0 if specifying a
	// datetime without a year.
	Year int64 `json:"year,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Day") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Day") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DateTime) MarshalJSON() ([]byte, error) {
	type NoMethod DateTime
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Device: Captures metadata about the device that recorded the measurement.
type Device struct {
	// DisplayName: Optional. An optional name for the device.
	DisplayName string `json:"displayName,omitempty"`
	// FormFactor: Optional. Captures the form factor of the device.
	//
	// Possible values:
	//   "FORM_FACTOR_UNSPECIFIED" - The form factor is unspecified.
	//   "FITNESS_BAND" - The device is a fitness band.
	//   "WATCH" - The device is a watch.
	//   "PHONE" - The device is a phone.
	//   "RING" - The device is a ring.
	//   "CHEST_STRAP" - The device is a chest strap.
	//   "SCALE" - The device is a scale.
	//   "TABLET" - The device is a tablet.
	//   "HEAD_MOUNTED" - The device is a head mounted device.
	//   "SMART_DISPLAY" - The device is a smart display.
	FormFactor string `json:"formFactor,omitempty"`
	// Manufacturer: Optional. An optional manufacturer of the device.
	Manufacturer string `json:"manufacturer,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DisplayName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DisplayName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Device) MarshalJSON() ([]byte, error) {
	type NoMethod Device
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Distance: Distance traveled over an interval of time.
type Distance struct {
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// Millimeters: Required. Distance in millimeters over the observed interval.
	Millimeters int64 `json:"millimeters,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Distance) MarshalJSON() ([]byte, error) {
	type NoMethod Distance
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// DistanceRollupValue: Result of the rollup of the user's distance.
type DistanceRollupValue struct {
	// MillimetersSum: Sum of the distance in millimeters.
	MillimetersSum int64 `json:"millimetersSum,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "MillimetersSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MillimetersSum") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s DistanceRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod DistanceRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Electrocardiogram: Represents an Electrocardiogram (ECG) measurement
// session. This data type is based on SaMD feature and any changes to it may
// require additional review.
type Electrocardiogram struct {
	// BeatsPerMinuteAvg: Optional. Average heart rate recorded during ECG reading
	// in beats per minute.
	BeatsPerMinuteAvg int64 `json:"beatsPerMinuteAvg,omitempty,string"`
	// Interval: Required. Observed interval. NOTE: Historical ECG data lacks
	// timezone offsets, so `start_utc_offset` and `end_utc_offset` will be missing
	// or default to zero. As a result, the civil time fields within this interval
	// will default to UTC. It is recommended to use physical time fields instead
	// for accurate time referencing. NOTE: The `start_time` and `end_time` of the
	// interval are equal, representing the reading time.
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// LeadNumber: Optional. The number of leads used for ECG reading.
	LeadNumber int64 `json:"leadNumber,omitempty"`
	// MedicalDeviceInfo: Output only. The meta information for the compatible
	// device used to conduct the measurement. ECG measurements typically populate
	// `firmware_version`, `feature_version`, and `device_model`.
	MedicalDeviceInfo *MedicalDeviceInfo `json:"medicalDeviceInfo,omitempty"`
	// MillivoltsScalingFactor: Optional. The factor by which to divide waveform
	// samples to get voltage in millivolts: millivolts = waveform_sample /
	// millivolts_scaling_factor.
	MillivoltsScalingFactor int64 `json:"millivoltsScalingFactor,omitempty"`
	// ResultClassification: Optional. The result classification of the ECG
	// reading.
	//
	// Possible values:
	//   "RESULT_CLASSIFICATION_UNSPECIFIED" - Unspecified result classification.
	//   "NORMAL_SINUS_RHYTHM" - Heart rhythm appears normal. Corresponds to result
	// "Normal Sinus Rhythm".
	//   "ATRIAL_FIBRILLATION" - Signs of Atrial Fibrillation detected. Corresponds
	// to result "Atrial Fibrillation".
	//   "INCONCLUSIVE" - The reading is inconclusive as it could not be
	// classified. Corresponds to result "Inconclusive".
	//   "INCONCLUSIVE_HIGH_HEART_RATE" - The reading is inconclusive as it could
	// not be classified because heart rate is high (>120bpm). Corresponds to
	// result "Inconclusive: High heart rate".
	//   "INCONCLUSIVE_LOW_HEART_RATE" - The reading is inconclusive as it could
	// not be classified because heart rate is low (<50bpm). Corresponds to result
	// "Inconclusive: Low heart rate".
	//   "UNREADABLE" - The reading is unreadable.
	//   "NOT_ANALYZED" - The reading was not analyzed.
	ResultClassification string `json:"resultClassification,omitempty"`
	// SamplingFrequencyHertz: Optional. The sampling frequency of waveform samples
	// in hertz.
	SamplingFrequencyHertz int64 `json:"samplingFrequencyHertz,omitempty"`
	// WaveformSamples: Optional. An array of voltage values representing lead I
	// ECG values. Each sample represents voltage difference in ECG graph. The
	// first value in array corresponds to the start of the reading.
	WaveformSamples []int64 `json:"waveformSamples,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinuteAvg") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinuteAvg") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Electrocardiogram) MarshalJSON() ([]byte, error) {
	type NoMethod Electrocardiogram
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Empty: A generic empty message that you can re-use to avoid defining
// duplicated empty messages in your APIs. A typical example is to use it as
// the request or the response type of an API method. For instance: service Foo
// { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
type Empty struct {
	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
}

// EndpointAuthorization: Authorization mechanism for a subscriber endpoint.
// For all requests sent by the Webhooks service, the JSON payload is
// cryptographically signed. The signature is delivered in the
// `GOOGLE-HEALTH-API-SIGNATURE` HTTP header. This is an ECDSA (NIST P256)
// signature of the JSON payload. Clients must verify this signature using
// Google Health API's public key to confirm the payload was sent by the Health
// API.
type EndpointAuthorization struct {
	// Secret: Required. Input only. Provides a client-provided secret that will be
	// sent with each notification to the subscriber endpoint using the
	// "Authorization" header. The value must include the authorization scheme,
	// e.g., "Bearer " or "Basic ", as it will be used as the full Authorization
	// header value. This secret is used by the API to test the endpoint during
	// `CreateSubscriber` and `UpdateSubscriber` calls, and will be sent in the
	// `Authorization` header for all subsequent webhook notifications to this
	// endpoint.
	Secret string `json:"secret,omitempty"`
	// SecretSet: Output only. Whether the secret is set.
	SecretSet bool `json:"secretSet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Secret") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Secret") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s EndpointAuthorization) MarshalJSON() ([]byte, error) {
	type NoMethod EndpointAuthorization
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// EnergyQuantity: Represents the energy quantity.
type EnergyQuantity struct {
	// Kcal: Required. The energy value in kilocalories.
	Kcal float64 `json:"kcal,omitempty"`
	// UserProvidedUnit: Optional. Value representing the user provided unit.
	//
	// Possible values:
	//   "ENERGY_UNIT_UNSPECIFIED" - Unspecified energy unit.
	//   "JOULE" - Value representing joule.
	//   "KILOJOULE" - Value representing kilojoule.
	//   "KILOCALORIE" - Value representing kilocalorie.
	//   "SMALL_CALORIE" - Value representing small calorie.
	//   "CALORIE" - Value representing calorie.
	UserProvidedUnit string `json:"userProvidedUnit,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Kcal") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Kcal") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s EnergyQuantity) MarshalJSON() ([]byte, error) {
	type NoMethod EnergyQuantity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *EnergyQuantity) UnmarshalJSON(data []byte) error {
	type NoMethod EnergyQuantity
	var s1 struct {
		Kcal gensupport.JSONFloat64 `json:"kcal"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Kcal = float64(s1.Kcal)
	return nil
}

// EnergyQuantityRollup: Rollup for the energy quantity.
type EnergyQuantityRollup struct {
	// KcalSum: Required. The sum of the energy in kilocalories.
	KcalSum float64 `json:"kcalSum,omitempty"`
	// UserProvidedUnitLast: Optional. The user provided unit on the last element.
	//
	// Possible values:
	//   "ENERGY_UNIT_UNSPECIFIED" - Unspecified energy unit.
	//   "JOULE" - Value representing joule.
	//   "KILOJOULE" - Value representing kilojoule.
	//   "KILOCALORIE" - Value representing kilocalorie.
	//   "SMALL_CALORIE" - Value representing small calorie.
	//   "CALORIE" - Value representing calorie.
	UserProvidedUnitLast string `json:"userProvidedUnitLast,omitempty"`
	// ForceSendFields is a list of field names (e.g. "KcalSum") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "KcalSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s EnergyQuantityRollup) MarshalJSON() ([]byte, error) {
	type NoMethod EnergyQuantityRollup
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *EnergyQuantityRollup) UnmarshalJSON(data []byte) error {
	type NoMethod EnergyQuantityRollup
	var s1 struct {
		KcalSum gensupport.JSONFloat64 `json:"kcalSum"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.KcalSum = float64(s1.KcalSum)
	return nil
}

// Exercise: An exercise that stores information about a physical activity.
type Exercise struct {
	// ActiveDuration: Optional. Duration excluding pauses.
	ActiveDuration string `json:"activeDuration,omitempty"`
	// CreateTime: Output only. Represents the timestamp of the creation of the
	// exercise.
	CreateTime string `json:"createTime,omitempty"`
	// DisplayName: Required. The localized, human-readable name of the exercise.
	// For all exercise types other than `OTHER`, the system ignores client input
	// and overrides this field with a generated name based on `exercise_type`
	// (e.g., "Walking" for `WALKING`). If `exercise_type` is `OTHER`, this field
	// can contain the user's custom, free-form display name.
	DisplayName string `json:"displayName,omitempty"`
	// ExerciseEvents: Optional. Exercise events that happen during an exercise,
	// such as pause & restarts.
	ExerciseEvents []*ExerciseEvent `json:"exerciseEvents,omitempty"`
	// ExerciseMetadata: Optional. Additional exercise metadata.
	ExerciseMetadata *ExerciseMetadata `json:"exerciseMetadata,omitempty"`
	// ExerciseType: Required. The type of activity performed during an exercise.
	//
	// Possible values:
	//   "EXERCISE_TYPE_UNSPECIFIED" - Exercise type is unspecified.
	//   "AEROBIC_WORKOUT" - Aerobic workout type.
	//   "ARCHERY" - Archery type.
	//   "ASSAULT_BIKE" - Assault bike type.
	//   "BACKPACKING" - Backpacking type.
	//   "BADMINTON" - Badminton type.
	//   "BALLET" - Ballet type.
	//   "BALLROOM_DANCE" - Ballroom dance type.
	//   "BARRE_CLASS" - Barre class type.
	//   "BASEBALL" - Baseball type.
	//   "BASKETBALL" - Basketball type.
	//   "BIKING" - Biking type.
	//   "BILLIARDS" - Billiards type.
	//   "BODY_WEIGHT" - Body weight type.
	//   "BOOTCAMP" - Bootcamp type.
	//   "BOWLING" - Bowling type.
	//   "BOXING" - Boxing type.
	//   "BREAKDANCING" - Breakdancing type.
	//   "CALISTHENICS" - Calisthenics type.
	//   "CANOEING" - Canoeing type.
	//   "CARDIO_SCULPT" - Cardio sculpt type.
	//   "CARDIO_WORKOUT" - Cardio workout type.
	//   "CARPENTRY" - Carpentry type.
	//   "CHEERLEADING" - Cheerleading type.
	//   "CIRCUIT_TRAINING" - Circuit training type.
	//   "CLEANING" - Cleaning type.
	//   "CLIMBING" - Climbing type.
	//   "CORE_TRAINING" - Core training type.
	//   "CRICKET" - Cricket type.
	//   "CROQUET" - Croquet type.
	//   "CROSS_COUNTRY_SKI" - Cross country ski type.
	//   "CROSS_TRAINING" - Cross training type.
	//   "CROSSFIT" - Crossfit type.
	//   "CURLING" - Curling type.
	//   "DANCING" - Dancing type.
	//   "DIVING" - Diving type.
	//   "ELECTRIC_BIKE" - Electric bike type.
	//   "ELECTRIC_SCOOTER" - Electric scooter type.
	//   "ELLIPTICAL" - Elliptical type.
	//   "EQUESTRIAN_SPORTS" - Equestrian sports type.
	//   "EXERCISE_CLASS" - Exercise class type.
	//   "FENCING" - Fencing type.
	//   "FIELD_HOCKEY" - Field hockey type.
	//   "FISHING" - Fishing type.
	//   "FITNESS_GAMING" - Fitness gaming type.
	//   "FOILING" - Foiling type.
	//   "FOOTBALL_AMERICAN" - Football american type.
	//   "FOOTBALL_AUSTRALIAN" - Football australian type.
	//   "FREE_WEIGHTS" - Free weights type.
	//   "FRISBEE_PLAYING_GENERAL" - Frisbee playing general type.
	//   "FUNCTIONAL_STRENGTH_TRAINING" - Functional strength training type.
	//   "GARDENING" - Gardening type.
	//   "GOLF" - Golf type.
	//   "GYMNASTICS" - Gymnastics type.
	//   "HANDBALL" - Handball type.
	//   "HAND_CYCLING" - Hand cycling type.
	//   "HIIT" - Hiit type.
	//   "HIKING" - Hiking type.
	//   "HIP_HOP" - Hip hop type.
	//   "HOCKEY" - Hockey type.
	//   "HOEING" - Hoeing type.
	//   "HOUSEHOLD_CHORES" - Household chores type.
	//   "HUNTING" - Hunting type.
	//   "ICE_SKATING" - Ice skating type.
	//   "INCLINE_RUN" - Incline run type.
	//   "INCLINE_WALK" - Incline walk type.
	//   "INDOOR_CLIMBING" - Indoor climbing type.
	//   "INTERVAL_WORKOUT" - Interval workout type.
	//   "JAZZ_DANCE" - Jazz dance type.
	//   "JIU_JITSU" - Jiu jitsu type.
	//   "JUMPING_ROPE" - Jumping rope type.
	//   "KARATE" - Karate type.
	//   "KAYAKING" - Kayaking type.
	//   "KICKBOXING" - Kickboxing type.
	//   "KITESURFING" - Kitesurfing type.
	//   "LACROSSE" - Lacrosse type.
	//   "MARTIAL_ARTS" - Martial arts type.
	//   "MEDITATE" - Meditate type.
	//   "MODERN_DANCE" - Modern dance type.
	//   "MOTOCROSS" - Motocross type.
	//   "MOTORCYCLE" - Motorcycle type.
	//   "MOUNTAIN_BIKE" - Mountain bike type.
	//   "MOWING_LAWN" - Mowing lawn type.
	//   "MUAY_THAI" - Muay thai type.
	//   "MULTISPORT" - Multisport type.
	//   "MUSICAL_PERFORMANCE" - Musical performance type.
	//   "NORDIC_WALKING" - Nordic walking type.
	//   "ORIENTEERING" - Orienteering type.
	//   "OTHER" - Other type.
	//   "OUTDOOR_BIKE" - Outdoor bike type.
	//   "OUTDOOR_WORKOUT" - Outdoor workout type.
	//   "PADDLEBOARDING" - Paddleboarding type.
	//   "PADEL" - Padel type.
	//   "PAINTING" - Painting type.
	//   "PARAGLIDING" - Paragliding type.
	//   "PARKOUR" - Parkour type.
	//   "PICKELBALL" - Pickelball type.
	//   "PILATES" - Pilates type.
	//   "POLO" - Polo type.
	//   "POWERLIFTING" - Powerlifting type.
	//   "POWER_WALKING" - Power walking type.
	//   "RACKET_SPORTS" - Racket sports type.
	//   "RACQUETBALL" - Racquetball type.
	//   "RESISTANCE_BANDS" - Resistance bands type.
	//   "ROCK_CLIMBING" - Rock climbing type.
	//   "ROLLERBLADING" - Rollerblading type.
	//   "ROLLER_SKATING" - Roller skating type.
	//   "ROWING" - Rowing type.
	//   "ROWING_MACHINE" - Rowing machine type.
	//   "RUCKING" - Rucking type.
	//   "RUGBY" - Rugby type.
	//   "RUNNING" - Running type.
	//   "SAILING" - Sailing type.
	//   "SCOOTERING" - Scootering type.
	//   "SCUBA_DIVING" - Scuba diving type.
	//   "SHOOTING" - Shooting type.
	//   "SHOVELING" - Shoveling type.
	//   "SKATEBOARDING" - Skateboarding type.
	//   "SKATING" - Skating type.
	//   "SKIING" - Skiing type.
	//   "SKYDIVING" - Skydiving type.
	//   "SNORKELING" - Snorkeling type.
	//   "SNOWBOARDING" - Snowboarding type.
	//   "SNOWMOBILING" - Snowmobiling type.
	//   "SNOWSHOEING" - Snowshoeing type.
	//   "SNOW_SPORT" - Snow sport type.
	//   "SOCCER" - Soccer type.
	//   "SOFTBALL" - Softball type.
	//   "SPEED_SKATING" - Speed skating type.
	//   "SPINNING" - Spinning type.
	//   "SPORT" - Sport type.
	//   "SQUASH" - Squash type.
	//   "STAIRCLIMBER" - Stairclimber type.
	//   "STATIONARY_BIKE" - Stationary bike type.
	//   "STEP_TRAINING" - Step training type.
	//   "STRENGTH_TRAINING" - Strength training type.
	//   "STRETCHING" - Stretching type.
	//   "STROLLER_WALK" - Stroller walk type.
	//   "SURFING" - Surfing type.
	//   "SWIMMING" - Swimming type.
	//   "SWIMMING_OPEN_WATER" - Swimming open water type.
	//   "SWIMMING_POOL" - Swimming pool type.
	//   "SYNCHRONIZED_SWIMMING" - Synchronized swimming type.
	//   "TABATA_WORKOUT" - Tabata workout type.
	//   "TABLE_TENNIS" - Table tennis type.
	//   "TAEKWONDO" - Taekwondo type.
	//   "TAI_CHI" - Tai chi type.
	//   "TANGO" - Tango type.
	//   "TENNIS" - Tennis type.
	//   "TRACK_AND_FIELD" - Track and field type.
	//   "TRAIL_RUN" - Trail run type.
	//   "TRAMPOLINE" - Trampoline type.
	//   "TREADMILL" - Treadmill type.
	//   "TREADMILL_WALK" - Treadmill walk type.
	//   "TRX" - Trx type.
	//   "ULTIMATE_FRISBEE" - Ultimate frisbee type.
	//   "UNICYCLING" - Unicycling type.
	//   "VOLLEYBALL" - Volleyball type.
	//   "VOLLEYBALL_BEACH" - Volleyball beach type.
	//   "WAKEBOARDING" - Wakeboarding type.
	//   "WALKING" - Walking type.
	//   "WALK_WITH_WEIGHTS" - Walk with weights type.
	//   "WATER_AEROBICS" - Water aerobics type.
	//   "WATER_JOGGING" - Water jogging type.
	//   "WATER_POLO" - Water polo type.
	//   "WATER_SKIING" - Water skiing type.
	//   "WATER_SPORT" - Water sport type.
	//   "WATER_VOLLEYBALL" - Water volleyball type.
	//   "WEEDING" - Weeding type.
	//   "WEIGHTLIFTING" - Weightlifting type.
	//   "WEIGHT_MACHINES" - Weight machines type.
	//   "WEIGHTS" - Weights type.
	//   "WHEELCHAIR" - Wheelchair type.
	//   "WINDSURFING" - Windsurfing type.
	//   "WORKOUT" - Workout type.
	//   "WRESTLING" - Wrestling type.
	//   "YOGA" - Yoga type.
	//   "YOGA_BIKRAM" - Yoga bikram type.
	//   "YOGA_HATHA" - Yoga hatha type.
	//   "YOGA_POWER" - Yoga power type.
	//   "YOGA_VINYASA" - Yoga vinyasa type.
	//   "ZUMBA" - Zumba type.
	ExerciseType string `json:"exerciseType,omitempty"`
	// Interval: Required. Observed exercise interval
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// MetricsSummary: Required. Summary metrics for this exercise ( )
	MetricsSummary *MetricsSummary `json:"metricsSummary,omitempty"`
	// Notes: Optional. Standard free-form notes captured at manual logging.
	Notes string `json:"notes,omitempty"`
	// SplitSummaries: Optional. Laps or splits recorded within an exercise. Laps
	// could be split based on distance or other criteria (duration, etc.) Laps
	// should not be overlapping with each other.
	SplitSummaries []*SplitSummary `json:"splitSummaries,omitempty"`
	// Splits: Optional. The default split is 1 km or 1 mile. - if the movement
	// distance is less than the default, then there are no splits - if the
	// movement distance is greater than or equal to the default, then we have
	// splits
	Splits []*SplitSummary `json:"splits,omitempty"`
	// UpdateTime: Output only. This is the timestamp of the last update to the
	// exercise.
	UpdateTime string `json:"updateTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveDuration") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveDuration") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Exercise) MarshalJSON() ([]byte, error) {
	type NoMethod Exercise
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ExerciseEvent: Represents instantaneous events that happen during an
// exercise, such as start, stop, pause, split.
type ExerciseEvent struct {
	// EventTime: Required. Exercise event time
	EventTime string `json:"eventTime,omitempty"`
	// EventUtcOffset: Required. Exercise event time offset from UTC
	EventUtcOffset string `json:"eventUtcOffset,omitempty"`
	// ExerciseEventType: Required. The type of the event, such as start, stop,
	// pause, resume.
	//
	// Possible values:
	//   "EXERCISE_EVENT_TYPE_UNSPECIFIED" - Exercise event type is unspecified.
	//   "START" - Exercise start event.
	//   "STOP" - Exercise stop event.
	//   "PAUSE" - Exercise pause event.
	//   "RESUME" - Exercise resume event.
	//   "AUTO_PAUSE" - Exercise auto-pause event.
	//   "AUTO_RESUME" - Exercise auto-resume event.
	ExerciseEventType string `json:"exerciseEventType,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EventTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EventTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ExerciseEvent) MarshalJSON() ([]byte, error) {
	type NoMethod ExerciseEvent
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ExerciseMetadata: Additional exercise metadata.
type ExerciseMetadata struct {
	// HasGps: Optional. Whether the exercise had GPS tracking.
	HasGps bool `json:"hasGps,omitempty"`
	// PoolLengthMillimeters: Optional. Pool length in millimeters. Only present in
	// the swimming exercises.
	PoolLengthMillimeters int64 `json:"poolLengthMillimeters,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "HasGps") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HasGps") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ExerciseMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod ExerciseMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ExportExerciseTcxResponse: Represents a Response for exporting exercise data
// in TCX format.
type ExportExerciseTcxResponse struct {
	// TcxData: Contains the exported TCX data. This field is intended for gRPC
	// clients, as media download integration is not supported for gRPC. HTTP
	// clients should instead use the `alt=media` query parameter to download the
	// raw binary TCX file.
	TcxData string `json:"tcxData,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "TcxData") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "TcxData") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ExportExerciseTcxResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ExportExerciseTcxResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Floors: Gained elevation measured in floors over the time interval
type Floors struct {
	// Count: Required. Number of floors in the recorded interval
	Count int64 `json:"count,omitempty,string"`
	// Interval: Required. Observed interval
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Count") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Count") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Floors) MarshalJSON() ([]byte, error) {
	type NoMethod Floors
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// FloorsRollupValue: Represents the result of the rollup of the user's floors.
type FloorsRollupValue struct {
	// CountSum: Sum of the floors count.
	CountSum int64 `json:"countSum,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "CountSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CountSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s FloorsRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod FloorsRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Food: Represents a food item.
type Food struct {
	// AccessLevel: Required. The access level of the food.
	//
	// Possible values:
	//   "FOOD_ACCESS_LEVEL_UNSPECIFIED" - Unspecified food access level.
	//   "FOOD_ACCESS_LEVEL_PUBLIC" - Public food access level.
	//   "FOOD_ACCESS_LEVEL_PRIVATE" - Private food access level.
	AccessLevel string `json:"accessLevel,omitempty"`
	// Brand: Optional. The brand of the food.
	Brand string `json:"brand,omitempty"`
	// DefaultServing: Required. Value representing the default serving of the
	// food.
	DefaultServing *FoodServing `json:"defaultServing,omitempty"`
	// Description: Optional. The description of the food.
	Description string `json:"description,omitempty"`
	// DisplayName: Required. The display name of the food.
	DisplayName string `json:"displayName,omitempty"`
	// EnergyAvg: Optional. Value representing the average energy of the food for
	// the default serving.
	EnergyAvg *EnergyQuantity `json:"energyAvg,omitempty"`
	// EnergyFromFat: Optional. Value representing the energy from fat of the food
	// for the default serving.
	EnergyFromFat *EnergyQuantity `json:"energyFromFat,omitempty"`
	// EnergyMax: Optional. Value representing the maximum energy of the food for
	// the default serving.
	EnergyMax *EnergyQuantity `json:"energyMax,omitempty"`
	// EnergyMin: Optional. Value representing the minimum energy of the food for
	// the default serving.
	EnergyMin *EnergyQuantity `json:"energyMin,omitempty"`
	// LanguageCode: Optional. The language code where the food is available in
	// format xx-XX. Supported values are defined in Settings.food_language_code.
	LanguageCode string `json:"languageCode,omitempty"`
	// MealType: Optional. The meal type associated with this food.
	//
	// Possible values:
	//   "MEAL_TYPE_UNSPECIFIED" - Unspecified meal type.
	//   "BEFORE_BREAKFAST" - Value representing a meal before breakfast.
	//   "BREAKFAST" - Value representing a breakfast.
	//   "BEFORE_LUNCH" - Value representing a morning snack.
	//   "LUNCH" - Value representing a lunch.
	//   "BEFORE_DINNER" - Value representing an afternoon snack.
	//   "DINNER" - Value representing dinner.
	//   "AFTER_DINNER" - Value representing an evening snack.
	//   "SNACK" - Value representing any meal outside of the usual three meals per
	// day.
	//   "ANYTIME" - Value representing any time (legacy NA).
	MealType string `json:"mealType,omitempty"`
	// Nutrients: Optional. Value representing the nutrients of the food for the
	// default serving.
	Nutrients []*NutrientQuantity `json:"nutrients,omitempty"`
	// Servings: Optional. The serving of the food.
	Servings []*FoodServing `json:"servings,omitempty"`
	// TotalCarbohydrate: Optional. Value representing the total carbohydrate of
	// the food for the default serving.
	TotalCarbohydrate *WeightQuantity `json:"totalCarbohydrate,omitempty"`
	// TotalFat: Optional. Value representing the total fat of the food for the
	// default serving.
	TotalFat *WeightQuantity `json:"totalFat,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AccessLevel") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AccessLevel") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Food) MarshalJSON() ([]byte, error) {
	type NoMethod Food
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// FoodMeasurementUnit: Represents a food measurement unit.
type FoodMeasurementUnit struct {
	// DisplayName: Required. The display name of the food measurement unit (e.g.,
	// "gram", "piece").
	DisplayName string `json:"displayName,omitempty"`
	// PluralDisplayName: Optional. The plural display name of the food measurement
	// unit (e.g., "grams", "pieces").
	PluralDisplayName string `json:"pluralDisplayName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DisplayName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DisplayName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s FoodMeasurementUnit) MarshalJSON() ([]byte, error) {
	type NoMethod FoodMeasurementUnit
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// FoodServing: Represents different properties and information about the
// serving of a specific food.
type FoodServing struct {
	// Amount: Optional. Amount of food consumed, fractional values are supported.
	Amount float64 `json:"amount,omitempty"`
	// FoodMeasurementUnit: Required. Food measurement unit
	FoodMeasurementUnit string `json:"foodMeasurementUnit,omitempty"`
	// FoodMeasurementUnitDisplayName: Output only. Legacy measurement unit for
	// serving size in singular form (e.g. "piece", "gram").
	FoodMeasurementUnitDisplayName string `json:"foodMeasurementUnitDisplayName,omitempty"`
	// FoodMeasurementUnitDisplayNamePlural: Output only. Legacy measurement unit
	// for serving size in plural form (e.g. "pieces", "grams").
	FoodMeasurementUnitDisplayNamePlural string `json:"foodMeasurementUnitDisplayNamePlural,omitempty"`
	// Multiplier: Optional. Value representing the multiplier used to compute the
	// energy when using this serving instead of the default serving.
	Multiplier float64 `json:"multiplier,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Amount") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Amount") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s FoodServing) MarshalJSON() ([]byte, error) {
	type NoMethod FoodServing
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *FoodServing) UnmarshalJSON(data []byte) error {
	type NoMethod FoodServing
	var s1 struct {
		Amount     gensupport.JSONFloat64 `json:"amount"`
		Multiplier gensupport.JSONFloat64 `json:"multiplier"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Amount = float64(s1.Amount)
	s.Multiplier = float64(s1.Multiplier)
	return nil
}

// GoogleDevicesandservicesHealthV4DataType: Represents a type of health data a
// user can have data points recorded for. It matches the parent resource of
// collection containing data points of the given type. Clients currently do
// not need to interact with this resource directly.
type GoogleDevicesandservicesHealthV4DataType struct {
	// Name: Identifier. The resource name of the data type. Format:
	// `users/{user}/dataTypes/{data_type}` See DataPoint.name for examples and
	// possible values.
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Name") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4DataType) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4DataType
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GoogleDevicesandservicesHealthV4User: Represents a user in the Google Health
// API. It matches the parent resource of collections owned by the user.
// Clients currently do not need to interact with this resource directly.
type GoogleDevicesandservicesHealthV4User struct {
	// Name: Identifier. The resource name of the user. The `{user}` ID is a
	// system-generated identifier, as described in Identity.health_user_id.
	// Format: `users/{user}`
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Name") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4User) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4User
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GoogleDevicesandservicesHealthV4WebhookNotificationCloudLog: Log message for
// a webhook notification sent by the Google Health API to a subscriber's
// endpoint. Includes the HTTP response received from the endpoint.
type GoogleDevicesandservicesHealthV4WebhookNotificationCloudLog struct {
	// HttpResponse: Required. Represents the HTTP response. This message includes
	// the status code, reason phrase, headers, and body.
	HttpResponse *HttpResponse `json:"httpResponse,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HttpResponse") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HttpResponse") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4WebhookNotificationCloudLog) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4WebhookNotificationCloudLog
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GoogleDevicesandservicesHealthV4betaDataType: Represents a type of health
// data a user can have data points recorded for. It matches the parent
// resource of collection containing data points of the given type. Clients
// currently do not need to interact with this resource directly.
type GoogleDevicesandservicesHealthV4betaDataType struct {
	// Name: Identifier. The resource name of the data type. Format:
	// `users/{user}/dataTypes/{data_type}` See DataPoint.name for examples and
	// possible values.
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Name") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4betaDataType) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4betaDataType
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GoogleDevicesandservicesHealthV4betaUser: Represents a user in the Google
// Health API. It matches the parent resource of collections owned by the user.
// Clients currently do not need to interact with this resource directly.
type GoogleDevicesandservicesHealthV4betaUser struct {
	// Name: Identifier. The resource name of the user. The `{user}` ID is a
	// system-generated identifier, as described in Identity.health_user_id.
	// Format: `users/{user}`
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Name") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4betaUser) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4betaUser
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GoogleDevicesandservicesHealthV4betaWebhookNotificationCloudLog: Log message
// for a webhook notification sent by the Google Health API to a subscriber's
// endpoint. Includes the HTTP response received from the endpoint.
type GoogleDevicesandservicesHealthV4betaWebhookNotificationCloudLog struct {
	// HttpResponse: Required. Represents the HTTP response. This message includes
	// the status code, reason phrase, headers, and body.
	HttpResponse *HttpResponse `json:"httpResponse,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HttpResponse") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HttpResponse") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GoogleDevicesandservicesHealthV4betaWebhookNotificationCloudLog) MarshalJSON() ([]byte, error) {
	type NoMethod GoogleDevicesandservicesHealthV4betaWebhookNotificationCloudLog
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HeartBeat: A single heart beat measurement.
type HeartBeat struct {
	// BeatsPerMinute: Required. The beats-per-minute value extrapolated from the
	// time before the following heart beat. This is calculated as 60000 / rr,
	// where rr is the gap between heart beats in milliseconds (IBI - Interbeat
	// Interval).
	BeatsPerMinute int64 `json:"beatsPerMinute,omitempty"`
	// CivilTime: Output only. The civil time in the timezone the subject is in at
	// the time of the observation.
	CivilTime *CivilDateTime `json:"civilTime,omitempty"`
	// PhysicalTime: Required. The time of the heart beat measurement.
	PhysicalTime string `json:"physicalTime,omitempty"`
	// UtcOffset: Required. The UTC offset of the user's timezone when the heart
	// beat measurement occurred.
	UtcOffset string `json:"utcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinute") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinute") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartBeat) MarshalJSON() ([]byte, error) {
	type NoMethod HeartBeat
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HeartRate: A heart rate measurement.
type HeartRate struct {
	// BeatsPerMinute: Required. The heart rate value in beats per minute.
	BeatsPerMinute int64 `json:"beatsPerMinute,omitempty,string"`
	// Metadata: Optional. Metadata about the heart rate sample.
	Metadata *HeartRateMetadata `json:"metadata,omitempty"`
	// SampleTime: Required. Observation time
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinute") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinute") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRate) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRate
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HeartRateMetadata: Heart rate metadata.
type HeartRateMetadata struct {
	// MotionContext: Optional. Indicates the user’s level of activity when the
	// heart rate sample was measured
	//
	// Possible values:
	//   "MOTION_CONTEXT_UNSPECIFIED" - The default value when no data is
	// available.
	//   "ACTIVE" - The user is active.
	//   "SEDENTARY" - The user is inactive.
	MotionContext string `json:"motionContext,omitempty"`
	// SensorLocation: Optional. Indicates the location of the sensor that measured
	// the heart rate.
	//
	// Possible values:
	//   "SENSOR_LOCATION_UNSPECIFIED" - The default value when no data is
	// available.
	//   "CHEST" - Chest sensor.
	//   "WRIST" - Wrist sensor.
	//   "FINGER" - Finger sensor.
	//   "HAND" - Hand sensor.
	//   "EAR_LOBE" - Ear lobe sensor.
	//   "FOOT" - Foot sensor.
	SensorLocation string `json:"sensorLocation,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MotionContext") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MotionContext") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HeartRateRollupValue: Represents the result of the rollup of the heart rate
// data type.
type HeartRateRollupValue struct {
	// BeatsPerMinuteAvg: The average heart rate value in the interval.
	BeatsPerMinuteAvg float64 `json:"beatsPerMinuteAvg,omitempty"`
	// BeatsPerMinuteMax: The maximum heart rate value in the interval.
	BeatsPerMinuteMax float64 `json:"beatsPerMinuteMax,omitempty"`
	// BeatsPerMinuteMin: The minimum heart rate value in the interval.
	BeatsPerMinuteMin float64 `json:"beatsPerMinuteMin,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinuteAvg") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinuteAvg") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *HeartRateRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod HeartRateRollupValue
	var s1 struct {
		BeatsPerMinuteAvg gensupport.JSONFloat64 `json:"beatsPerMinuteAvg"`
		BeatsPerMinuteMax gensupport.JSONFloat64 `json:"beatsPerMinuteMax"`
		BeatsPerMinuteMin gensupport.JSONFloat64 `json:"beatsPerMinuteMin"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BeatsPerMinuteAvg = float64(s1.BeatsPerMinuteAvg)
	s.BeatsPerMinuteMax = float64(s1.BeatsPerMinuteMax)
	s.BeatsPerMinuteMin = float64(s1.BeatsPerMinuteMin)
	return nil
}

// HeartRateVariability: Captures user's heart rate variability (HRV) as
// measured by the root mean square of successive differences (RMSSD) between
// normal heartbeats or by standard deviation of the inter-beat intervals
// (SDNN).
type HeartRateVariability struct {
	// Metadata: Optional. Metadata used in 1P surfaces.
	Metadata *HeartRateVariabilityMetadata `json:"metadata,omitempty"`
	// RootMeanSquareOfSuccessiveDifferencesMilliseconds: Optional. The root mean
	// square of successive differences between normal heartbeats. This is a
	// measure of heart rate variability used by Google Health.
	RootMeanSquareOfSuccessiveDifferencesMilliseconds float64 `json:"rootMeanSquareOfSuccessiveDifferencesMilliseconds,omitempty"`
	// SampleTime: Required. The time of the heart rate variability measurement.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// StandardDeviationMilliseconds: Optional. The standard deviation of the heart
	// rate variability measurement.
	StandardDeviationMilliseconds float64 `json:"standardDeviationMilliseconds,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Metadata") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Metadata") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateVariability) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateVariability
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *HeartRateVariability) UnmarshalJSON(data []byte) error {
	type NoMethod HeartRateVariability
	var s1 struct {
		RootMeanSquareOfSuccessiveDifferencesMilliseconds gensupport.JSONFloat64 `json:"rootMeanSquareOfSuccessiveDifferencesMilliseconds"`
		StandardDeviationMilliseconds                     gensupport.JSONFloat64 `json:"standardDeviationMilliseconds"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.RootMeanSquareOfSuccessiveDifferencesMilliseconds = float64(s1.RootMeanSquareOfSuccessiveDifferencesMilliseconds)
	s.StandardDeviationMilliseconds = float64(s1.StandardDeviationMilliseconds)
	return nil
}

// HeartRateVariabilityMetadata: Metadata for HeartRateVariability.
type HeartRateVariabilityMetadata struct {
	// HighFrequencyPower: Optional. The power in interbeat interval fluctuations
	// within the high frequency band (0.15 Hz - 0.4 Hz).
	HighFrequencyPower float64 `json:"highFrequencyPower,omitempty"`
	// LowFrequencyPower: Optional. The power in interbeat interval fluctuations
	// within the low frequency band (0.04 Hz - 0.15 Hz).
	LowFrequencyPower float64 `json:"lowFrequencyPower,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HighFrequencyPower") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HighFrequencyPower") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateVariabilityMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateVariabilityMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *HeartRateVariabilityMetadata) UnmarshalJSON(data []byte) error {
	type NoMethod HeartRateVariabilityMetadata
	var s1 struct {
		HighFrequencyPower gensupport.JSONFloat64 `json:"highFrequencyPower"`
		LowFrequencyPower  gensupport.JSONFloat64 `json:"lowFrequencyPower"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.HighFrequencyPower = float64(s1.HighFrequencyPower)
	s.LowFrequencyPower = float64(s1.LowFrequencyPower)
	return nil
}

// HeartRateVariabilityPersonalRangeRollupValue: Represents the result of the
// rollup of the user's daily heart rate variability personal range.
type HeartRateVariabilityPersonalRangeRollupValue struct {
	// AverageHeartRateVariabilityMillisecondsMax: The upper bound of the user's
	// average heart rate variability personal range.
	AverageHeartRateVariabilityMillisecondsMax float64 `json:"averageHeartRateVariabilityMillisecondsMax,omitempty"`
	// AverageHeartRateVariabilityMillisecondsMin: The lower bound of the user's
	// average heart rate variability personal range.
	AverageHeartRateVariabilityMillisecondsMin float64 `json:"averageHeartRateVariabilityMillisecondsMin,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "AverageHeartRateVariabilityMillisecondsMax") to unconditionally include in
	// API requests. By default, fields with empty or default values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "AverageHeartRateVariabilityMillisecondsMax") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateVariabilityPersonalRangeRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateVariabilityPersonalRangeRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *HeartRateVariabilityPersonalRangeRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod HeartRateVariabilityPersonalRangeRollupValue
	var s1 struct {
		AverageHeartRateVariabilityMillisecondsMax gensupport.JSONFloat64 `json:"averageHeartRateVariabilityMillisecondsMax"`
		AverageHeartRateVariabilityMillisecondsMin gensupport.JSONFloat64 `json:"averageHeartRateVariabilityMillisecondsMin"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AverageHeartRateVariabilityMillisecondsMax = float64(s1.AverageHeartRateVariabilityMillisecondsMax)
	s.AverageHeartRateVariabilityMillisecondsMin = float64(s1.AverageHeartRateVariabilityMillisecondsMin)
	return nil
}

// HeartRateZone: The heart rate zone.
type HeartRateZone struct {
	// HeartRateZoneType: Required. The heart rate zone type.
	//
	// Possible values:
	//   "HEART_RATE_ZONE_TYPE_UNSPECIFIED" - Unspecified heart rate zone.
	//   "LIGHT" - The light heart rate zone.
	//   "MODERATE" - The moderate heart rate zone.
	//   "VIGOROUS" - The vigorous heart rate zone.
	//   "PEAK" - The peak heart rate zone.
	HeartRateZoneType string `json:"heartRateZoneType,omitempty"`
	// MaxBeatsPerMinute: Required. Maximum heart rate for this zone in beats per
	// minute.
	MaxBeatsPerMinute int64 `json:"maxBeatsPerMinute,omitempty,string"`
	// MinBeatsPerMinute: Required. Minimum heart rate for this zone in beats per
	// minute.
	MinBeatsPerMinute int64 `json:"minBeatsPerMinute,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "HeartRateZoneType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HeartRateZoneType") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HeartRateZone) MarshalJSON() ([]byte, error) {
	type NoMethod HeartRateZone
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Height: Body height measurement.
type Height struct {
	// HeightMillimeters: Required. Height of the user in millimeters.
	HeightMillimeters int64 `json:"heightMillimeters,omitempty,string"`
	// SampleTime: Required. The time at which the height was recorded.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HeightMillimeters") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HeightMillimeters") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Height) MarshalJSON() ([]byte, error) {
	type NoMethod Height
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HttpBody: Message that represents an arbitrary HTTP body. It should only be
// used for payload formats that can't be represented as JSON, such as raw
// binary or an HTML page. This message can be used both in streaming and
// non-streaming API methods in the request as well as the response. It can be
// used as a top-level request field, which is convenient if one wants to
// extract parameters from either the URL or HTTP template into the request
// fields and also want access to the raw HTTP body. Example: message
// GetResourceRequest { // A unique request id. string request_id = 1; // The
// raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; }
// service ResourceService { rpc GetResource(GetResourceRequest) returns
// (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns
// (google.protobuf.Empty); } Example with streaming methods: service
// CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream
// google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns
// (stream google.api.HttpBody); } Use of this type only changes how the
// request and response bodies are handled, all other features will continue to
// work unchanged.
type HttpBody struct {
	// ContentType: The HTTP Content-Type header value specifying the content type
	// of the body.
	ContentType string `json:"contentType,omitempty"`
	// Data: The HTTP request/response body as raw binary.
	Data string `json:"data,omitempty"`
	// Extensions: Application specific response metadata. Must be set in the first
	// response for streaming APIs.
	Extensions []googleapi.RawMessage `json:"extensions,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "ContentType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ContentType") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HttpBody) MarshalJSON() ([]byte, error) {
	type NoMethod HttpBody
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HttpHeader: Represents an HTTP header.
type HttpHeader struct {
	// Key: The HTTP header key. It is case insensitive.
	Key string `json:"key,omitempty"`
	// Value: The HTTP header value.
	Value string `json:"value,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Key") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Key") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HttpHeader) MarshalJSON() ([]byte, error) {
	type NoMethod HttpHeader
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HttpResponse: Represents an HTTP response.
type HttpResponse struct {
	// Body: The HTTP response body. If the body is not expected, it should be
	// empty.
	Body string `json:"body,omitempty"`
	// Headers: The HTTP response headers. The ordering of the headers is
	// significant. Multiple headers with the same key may present for the
	// response.
	Headers []*HttpHeader `json:"headers,omitempty"`
	// Reason: The HTTP reason phrase, such as "OK" or "Not Found".
	Reason string `json:"reason,omitempty"`
	// Status: The HTTP status code, such as 200 or 404.
	Status int64 `json:"status,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Body") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Body") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HttpResponse) MarshalJSON() ([]byte, error) {
	type NoMethod HttpResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HydrationLog: Holds information about a user logged hydration.
type HydrationLog struct {
	// AmountConsumed: Required. Amount of liquid (ex. water) consumed.
	AmountConsumed *VolumeQuantity `json:"amountConsumed,omitempty"`
	// Interval: Required. Observed interval.
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountConsumed") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountConsumed") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HydrationLog) MarshalJSON() ([]byte, error) {
	type NoMethod HydrationLog
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// HydrationLogRollupValue: Represents the result of the rollup of the
// hydration log data type.
type HydrationLogRollupValue struct {
	// AmountConsumed: Rollup for amount consumed.
	AmountConsumed *VolumeQuantityRollup `json:"amountConsumed,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountConsumed") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountConsumed") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s HydrationLogRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod HydrationLogRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Identity: Represents details about the Google user's identity.
type Identity struct {
	// HealthUserId: Output only. The Google User Identifier in the Google Health
	// APIs. It matches the `{user}` resource ID segment in the resource name
	// paths, e.g. `users/{user}/dataTypes/steps`. Valid values are strings of 1-63
	// characters, and valid characters are lowercase and uppercase letters,
	// numbers, and hyphens.
	HealthUserId string `json:"healthUserId,omitempty"`
	// LegacyUserId: Output only. The legacy Fitbit User identifier. This is the
	// Fitbit ID used in the legacy Fitbit APIs (v1-v3). It can be referenced by
	// clients migrating from the legacy Fitbit APIs to map their existing
	// identifiers to the new Google user ID. It **must not** be used for any other
	// purpose. It is not of any use for new clients using only the Google Health
	// APIs. Valid values are strings of 1-63 characters, and valid characters are
	// lowercase and uppercase letters, numbers, and hyphens.
	LegacyUserId string `json:"legacyUserId,omitempty"`
	// Name: Identifier. The resource name of this Identity resource. Format:
	// `users/me/identity`
	Name string `json:"name,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "HealthUserId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HealthUserId") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Identity) MarshalJSON() ([]byte, error) {
	type NoMethod Identity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Interval: Represents a time interval, encoded as a Timestamp start
// (inclusive) and a Timestamp end (exclusive). The start must be less than or
// equal to the end. When the start equals the end, the interval is empty
// (matches no time). When both start and end are unspecified, the interval
// matches any time.
type Interval struct {
	// EndTime: Optional. Exclusive end of the interval. If specified, a Timestamp
	// matching this interval will have to be before the end.
	EndTime string `json:"endTime,omitempty"`
	// StartTime: Optional. Inclusive start of the interval. If specified, a
	// Timestamp matching this interval will have to be the same or after the
	// start.
	StartTime string `json:"startTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EndTime") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Interval) MarshalJSON() ([]byte, error) {
	type NoMethod Interval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// IrnProfile: Irregular Rhythm Notifications (IRN) Profile details. The
// Irregular Rhythm Notifications (IRN) feature checks for signs of atrial
// fibrillation (AFib). The IrnProfile details include information about the
// user's onboarding status, enrollment status, and the last update time of
// analyzable data for this feature.
type IrnProfile struct {
	// EnrollmentStatus: Required. Whether or not the user is currently enrolled in
	// having their data processed for IRN alerts.
	EnrollmentStatus bool `json:"enrollmentStatus,omitempty"`
	// Name: Identifier. The resource name of this IrnProfile resource. Format:
	// `users/{user}/irnProfile` Example: `users/1234567890/irnProfile` or
	// `users/me/irnProfile` The {user} ID is a system-generated Google Health API
	// user ID, a string of 1-63 characters consisting of lowercase and uppercase
	// letters, numbers, and hyphens. The literal `me` can also be used to refer to
	// the authenticated user.
	Name string `json:"name,omitempty"`
	// OnboardingStatus: Required. Whether or not the user has onboarded onto the
	// IRN feature.
	OnboardingStatus bool `json:"onboardingStatus,omitempty"`
	// UpdateTime: Output only. The timestamp of the last piece of analyzable data
	// synced by the user.
	UpdateTime string `json:"updateTime,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "EnrollmentStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EnrollmentStatus") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s IrnProfile) MarshalJSON() ([]byte, error) {
	type NoMethod IrnProfile
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// IrregularRhythmNotification: Represents an Irregular Rhythm Notification
// alert, indicating a potential sign of atrial fibrillation (AFib). This data
// type is based on SaMD feature and any changes to it may require additional
// review.
type IrregularRhythmNotification struct {
	// AlertWindows: Optional. The overlapping analysis windows that were used to
	// evaluate rhythm for potential AFib, containing specific information about
	// the user's heart rhythm.
	AlertWindows []*AlertWindow `json:"alertWindows,omitempty"`
	// Interval: Required. Observed interval.
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// MedicalDeviceInfo: Output only. The meta information for the compatible
	// device used to conduct the measurement. Irregular Rhythm Notification
	// measurements typically populate `algorithm_version`, `service_version`, and
	// `device_model`.
	MedicalDeviceInfo *MedicalDeviceInfo `json:"medicalDeviceInfo,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AlertWindows") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AlertWindows") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s IrregularRhythmNotification) MarshalJSON() ([]byte, error) {
	type NoMethod IrregularRhythmNotification
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ListDataPointsResponse: Response containing raw data points matching the
// query
type ListDataPointsResponse struct {
	// DataPoints: Data points matching the query
	DataPoints []*DataPoint `json:"dataPoints,omitempty"`
	// NextPageToken: Next page token, empty if the response is complete
	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. "DataPoints") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataPoints") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ListDataPointsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ListDataPointsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ListPairedDevicesResponse: Response message for ListPairedDevices.
type ListPairedDevicesResponse struct {
	// NextPageToken: A token, which can be sent as `page_token` to retrieve the
	// next page. If this field is omitted, there are no subsequent pages.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// PairedDevices: The paired devices of the user.
	PairedDevices []*PairedDevice `json:"pairedDevices,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ListPairedDevicesResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ListPairedDevicesResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ListSubscribersResponse: Response message for ListSubscribers.
type ListSubscribersResponse struct {
	// NextPageToken: A token, which can be sent as `page_token` to retrieve the
	// next page. If this field is omitted, there are no subsequent pages.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// Subscribers: Subscribers from the specified project.
	Subscribers []*Subscriber `json:"subscribers,omitempty"`
	// TotalSize: The total number of subscribers matching the request.
	TotalSize int64 `json:"totalSize,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ListSubscribersResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ListSubscribersResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ListSubscriptionsResponse: Response message for ListSubscriptions.
type ListSubscriptionsResponse struct {
	// NextPageToken: A token, which can be sent as `page_token` to retrieve the
	// next page. If this field is omitted, there are no subsequent pages.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// Subscriptions: The subscriptions from the specified subscriber.
	Subscriptions []*Subscription `json:"subscriptions,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ListSubscriptionsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ListSubscriptionsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ManifestParams: Represents the POST body contained in a
// GetShlManifestRequest This message is nested to represent that See
// https://build.fhir.org/ig/HL7/smart-health-cards-and-links/links-specification.html#smart-health-link-manifest-request
type ManifestParams struct {
	// EmbeddedLengthMax: Optional. Integer upper bound on the length of embedded
	// payloads
	EmbeddedLengthMax int64 `json:"embeddedLengthMax,omitempty"`
	// Passcode: Optional.
	Passcode string `json:"passcode,omitempty"`
	// Recipient: Required. A string describing the recipient (e.g.,the name of an
	// organization or person) suitable for display to the Receiving User
	Recipient string `json:"recipient,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EmbeddedLengthMax") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EmbeddedLengthMax") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ManifestParams) MarshalJSON() ([]byte, error) {
	type NoMethod ManifestParams
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// MedicalDeviceInfo: Software as Medical Device (SaMD) metadata. Used to
// construct the Unique Device Identifier (UDI).
type MedicalDeviceInfo struct {
	// AlgorithmVersion: Output only. The algorithm version used by the feature.
	AlgorithmVersion string `json:"algorithmVersion,omitempty"`
	// DeviceModel: Output only. The model name or device type of the compatible
	// device used to collect the data.
	DeviceModel string `json:"deviceModel,omitempty"`
	// FeatureVersion: Output only. The version of the feature/app running on the
	// device.
	FeatureVersion string `json:"featureVersion,omitempty"`
	// FirmwareVersion: Output only. The firmware version running on the compatible
	// device used to collect the data.
	FirmwareVersion string `json:"firmwareVersion,omitempty"`
	// ServiceVersion: Output only. The service version used by the feature.
	ServiceVersion string `json:"serviceVersion,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AlgorithmVersion") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AlgorithmVersion") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MedicalDeviceInfo) MarshalJSON() ([]byte, error) {
	type NoMethod MedicalDeviceInfo
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// MenstrualPeriod: Menstrual period record.
type MenstrualPeriod struct {
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// Notes: Optional. Standard free-form notes captured at manual logging.
	Notes string `json:"notes,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MenstrualPeriod) MarshalJSON() ([]byte, error) {
	type NoMethod MenstrualPeriod
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// MetricsSummary: Summary metrics for an exercise.
type MetricsSummary struct {
	// ActiveZoneMinutes: Optional. Total active zone minutes for the exercise.
	ActiveZoneMinutes int64 `json:"activeZoneMinutes,omitempty,string"`
	// AverageHeartRateBeatsPerMinute: Optional. Average heart rate during the
	// exercise.
	AverageHeartRateBeatsPerMinute int64 `json:"averageHeartRateBeatsPerMinute,omitempty,string"`
	// AveragePaceSecondsPerMeter: Optional. Average pace in seconds per meter.
	AveragePaceSecondsPerMeter float64 `json:"averagePaceSecondsPerMeter,omitempty"`
	// AverageSpeedMillimetersPerSecond: Optional. Average speed in millimeters per
	// second.
	AverageSpeedMillimetersPerSecond float64 `json:"averageSpeedMillimetersPerSecond,omitempty"`
	// CaloriesKcal: Optional. Total calories burned by the user during the
	// exercise.
	CaloriesKcal float64 `json:"caloriesKcal,omitempty"`
	// DistanceMillimeters: Optional. Total distance covered by the user during the
	// exercise.
	DistanceMillimeters float64 `json:"distanceMillimeters,omitempty"`
	// ElevationGainMillimeters: Optional. Total elevation gain during the
	// exercise.
	ElevationGainMillimeters float64 `json:"elevationGainMillimeters,omitempty"`
	// HeartRateZoneDurations: Optional. Time spent in each heart rate zone.
	HeartRateZoneDurations *TimeInHeartRateZones `json:"heartRateZoneDurations,omitempty"`
	// MobilityMetrics: Optional. Mobility workouts specific metrics. Only present
	// in the advanced running exercises.
	MobilityMetrics *MobilityMetrics `json:"mobilityMetrics,omitempty"`
	// RunVo2Max: Optional. Run VO2 max value for the exercise. Only present in the
	// running exercises at the top level as in the summary of the whole exercise.
	RunVo2Max float64 `json:"runVo2Max,omitempty"`
	// Steps: Optional. Total steps taken during the exercise.
	Steps int64 `json:"steps,omitempty,string"`
	// TotalSwimLengths: Optional. Number of full pool lengths completed during the
	// exercise. Only present in the swimming exercises at the top level as in the
	// summary of the whole exercise.
	TotalSwimLengths float64 `json:"totalSwimLengths,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveZoneMinutes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveZoneMinutes") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MetricsSummary) MarshalJSON() ([]byte, error) {
	type NoMethod MetricsSummary
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *MetricsSummary) UnmarshalJSON(data []byte) error {
	type NoMethod MetricsSummary
	var s1 struct {
		AveragePaceSecondsPerMeter       gensupport.JSONFloat64 `json:"averagePaceSecondsPerMeter"`
		AverageSpeedMillimetersPerSecond gensupport.JSONFloat64 `json:"averageSpeedMillimetersPerSecond"`
		CaloriesKcal                     gensupport.JSONFloat64 `json:"caloriesKcal"`
		DistanceMillimeters              gensupport.JSONFloat64 `json:"distanceMillimeters"`
		ElevationGainMillimeters         gensupport.JSONFloat64 `json:"elevationGainMillimeters"`
		RunVo2Max                        gensupport.JSONFloat64 `json:"runVo2Max"`
		TotalSwimLengths                 gensupport.JSONFloat64 `json:"totalSwimLengths"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AveragePaceSecondsPerMeter = float64(s1.AveragePaceSecondsPerMeter)
	s.AverageSpeedMillimetersPerSecond = float64(s1.AverageSpeedMillimetersPerSecond)
	s.CaloriesKcal = float64(s1.CaloriesKcal)
	s.DistanceMillimeters = float64(s1.DistanceMillimeters)
	s.ElevationGainMillimeters = float64(s1.ElevationGainMillimeters)
	s.RunVo2Max = float64(s1.RunVo2Max)
	s.TotalSwimLengths = float64(s1.TotalSwimLengths)
	return nil
}

// MobilityMetrics: Mobility workouts specific metrics
type MobilityMetrics struct {
	// AvgCadenceStepsPerMinute: Optional. Cadence is a measure of the frequency of
	// your foot strikes. Steps / min in real time during workout.
	AvgCadenceStepsPerMinute float64 `json:"avgCadenceStepsPerMinute,omitempty"`
	// AvgGroundContactTimeDuration: Optional. The ground contact time for a
	// particular stride is the amount of time for which the foot was in contact
	// with the ground on that stride
	AvgGroundContactTimeDuration string `json:"avgGroundContactTimeDuration,omitempty"`
	// AvgStrideLengthMillimeters: Optional. Stride length is a measure of the
	// distance covered by a single stride
	AvgStrideLengthMillimeters int64 `json:"avgStrideLengthMillimeters,omitempty,string"`
	// AvgVerticalOscillationMillimeters: Optional. Distance off the ground your
	// center of mass moves with each stride while running
	AvgVerticalOscillationMillimeters int64 `json:"avgVerticalOscillationMillimeters,omitempty,string"`
	// AvgVerticalRatio: Optional. Vertical oscillation/stride length between [5.0,
	// 11.0].
	AvgVerticalRatio float64 `json:"avgVerticalRatio,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AvgCadenceStepsPerMinute")
	// to unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AvgCadenceStepsPerMinute") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MobilityMetrics) MarshalJSON() ([]byte, error) {
	type NoMethod MobilityMetrics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *MobilityMetrics) UnmarshalJSON(data []byte) error {
	type NoMethod MobilityMetrics
	var s1 struct {
		AvgCadenceStepsPerMinute gensupport.JSONFloat64 `json:"avgCadenceStepsPerMinute"`
		AvgVerticalRatio         gensupport.JSONFloat64 `json:"avgVerticalRatio"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AvgCadenceStepsPerMinute = float64(s1.AvgCadenceStepsPerMinute)
	s.AvgVerticalRatio = float64(s1.AvgVerticalRatio)
	return nil
}

// Moods: Moods record.
type Moods struct {
	// Moods: Required. The moods logged.
	//
	// Possible values:
	//   "MOOD_UNSPECIFIED" - Unspecified mood.
	//   "AMAZED" - Amazed.
	//   "AMUSED" - Amused.
	//   "ANGRY" - Angry.
	//   "ANNOYED" - Annoyed.
	//   "ANXIOUS" - Anxious.
	//   "HAPPY" - Happy.
	//   "CONTENT" - Content.
	//   "SAD" - Sad.
	//   "WORRIED" - Worried.
	//   "FRUSTRATED" - Frustrated.
	//   "EXCITED" - Excited.
	//   "CALM" - Calm.
	//   "STRESSED" - Stressed.
	//   "ASHAMED" - Ashamed.
	//   "BRAVE" - Brave.
	//   "CONFIDENT" - Confident.
	//   "DISAPPOINTED" - Disappointed.
	//   "DISCOURAGED" - Discouraged.
	//   "DISGUSTED" - Disgusted.
	//   "DRAINED" - Drained.
	//   "EMBARRASSED" - Embarrassed.
	//   "GRATEFUL" - Grateful.
	//   "GUILTY" - Guilty.
	//   "HOPEFUL" - Hopeful.
	//   "HOPELESS" - Hopeless.
	//   "INDIFFERENT" - Indifferent.
	//   "IRRITATED" - Irritated.
	//   "JEALOUS" - Jealous.
	//   "JOYFUL" - Joyful.
	//   "LONELY" - Lonely.
	//   "OVERWHELMED" - Overwhelmed.
	//   "PASSIONATE" - Passionate.
	//   "PEACEFUL" - Peaceful.
	//   "PROUD" - Proud.
	//   "RELIEVED" - Relieved.
	//   "SATISFIED" - Satisfied.
	//   "SCARED" - Scared.
	//   "SURPRISED" - Surprised.
	//   "ENERGIZED" - Energized.
	//   "FATIGUED" - Fatigued.
	//   "VERY_CALM" - Very calm.
	//   "VERY_STRESSED" - Very stressed.
	//   "NEUTRAL" - Neutral.
	//   "AFRAID" - Afraid.
	//   "HURTING" - Hurting.
	//   "BORED" - Bored.
	//   "BITTER" - Bitter.
	//   "ENVIOUS" - Envious.
	//   "CONFUSED" - Confused.
	//   "CURIOUS" - Curious.
	//   "AWESTRUCK" - Awestruck.
	//   "INSPIRED" - Inspired.
	//   "LONGING" - Longing.
	//   "ACCOMPLISHED" - Accomplished.
	//   "LOVING" - Loving.
	//   "COMPASSIONATE" - Compassionate.
	Moods []string `json:"moods,omitempty"`
	// SampleTime: Required. The time at which moods were measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// Valences: Optional. The valences.
	//
	// Possible values:
	//   "VALENCE_UNSPECIFIED" - Unspecified valence.
	//   "UNPLEASANT" - Unpleasant.
	//   "BASELINE" - Baseline.
	//   "PLEASANT" - Pleasant.
	Valences []string `json:"valences,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Moods") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Moods") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Moods) MarshalJSON() ([]byte, error) {
	type NoMethod Moods
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// NutrientQuantity: Represents the quantity of a nutrient.
type NutrientQuantity struct {
	// Nutrient: Required. The nutrient type.
	//
	// Possible values:
	//   "NUTRIENT_UNSPECIFIED" - Unspecified nutrient.
	//   "BIOTIN" - Value representing biotin nutrient.
	//   "CAFFEINE" - Value representing caffeine nutrient.
	//   "CALCIUM" - Value representing calcium nutrient.
	//   "CHLORIDE" - Value representing chloride nutrient.
	//   "CARBOHYDRATES" - Value representing carbohydrates nutrient.
	//   "CHOLESTEROL" - Value representing cholesterol nutrient.
	//   "CHROMIUM" - Value representing chromium nutrient.
	//   "COPPER" - Value representing copper nutrient.
	//   "DIETARY_FIBER" - Value representing dietary fiber nutrient.
	//   "FOLIC_ACID" - Value representing folic acid nutrient.
	//   "IODINE" - Value representing iodine nutrient.
	//   "IRON" - Value representing iron nutrient.
	//   "MAGNESIUM" - Value representing magnesium nutrient.
	//   "MANGANESE" - Value representing manganese nutrient.
	//   "MOLYBDENUM" - Value representing molybdenum nutrient.
	//   "MONOUNSATURATED_FAT" - Value representing monounsaturated fat nutrient.
	//   "NIACIN" - Value representing niacin nutrient.
	//   "PANTOTHENIC_ACID" - Value representing pantothenic acid nutrient.
	//   "PHOSPHORUS" - Value representing phosphorus nutrient.
	//   "POLYUNSATURATED_FAT" - Value representing polyunsaturated fat nutrient.
	//   "POTASSIUM" - Value representing potassium nutrient.
	//   "PROTEIN" - Value representing protein nutrient.
	//   "RIBOFLAVIN" - Value representing riboflavin nutrient.
	//   "SATURATED_FAT" - Value representing saturated fat nutrient.
	//   "SELENIUM" - Value representing selenium nutrient.
	//   "SODIUM" - Value representing sodium nutrient.
	//   "SUGAR" - Value representing sugar nutrient.
	//   "THIAMIN" - Value representing thiamin nutrient.
	//   "TRANS_FAT" - Value representing trans fat nutrient.
	//   "UNSATURATED_FAT" - Value representing unsaturated fat nutrient.
	//   "VITAMIN_A" - Value representing vitamin A nutrient.
	//   "VITAMIN_B12" - Value representing vitamin B12 nutrient.
	//   "VITAMIN_B6" - Value representing vitamin B6 nutrient.
	//   "VITAMIN_C" - Value representing vitamin C nutrient.
	//   "VITAMIN_D" - Value representing vitamin D nutrient.
	//   "VITAMIN_E" - Value representing vitamin E nutrient.
	//   "VITAMIN_K" - Value representing vitamin K nutrient.
	//   "ZINC" - Value representing zinc nutrient.
	//   "FOLATE" - Value representing folate nutrient.
	Nutrient string `json:"nutrient,omitempty"`
	// Quantity: Required. The quantity of the nutrient, measured in grams.
	Quantity *WeightQuantity `json:"quantity,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Nutrient") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Nutrient") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s NutrientQuantity) MarshalJSON() ([]byte, error) {
	type NoMethod NutrientQuantity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// NutrientQuantityRollup: Nutrient quantity rollup.
type NutrientQuantityRollup struct {
	// Nutrient: Required. Aggregated nutrient.
	//
	// Possible values:
	//   "NUTRIENT_UNSPECIFIED" - Unspecified nutrient.
	//   "BIOTIN" - Value representing biotin nutrient.
	//   "CAFFEINE" - Value representing caffeine nutrient.
	//   "CALCIUM" - Value representing calcium nutrient.
	//   "CHLORIDE" - Value representing chloride nutrient.
	//   "CARBOHYDRATES" - Value representing carbohydrates nutrient.
	//   "CHOLESTEROL" - Value representing cholesterol nutrient.
	//   "CHROMIUM" - Value representing chromium nutrient.
	//   "COPPER" - Value representing copper nutrient.
	//   "DIETARY_FIBER" - Value representing dietary fiber nutrient.
	//   "FOLIC_ACID" - Value representing folic acid nutrient.
	//   "IODINE" - Value representing iodine nutrient.
	//   "IRON" - Value representing iron nutrient.
	//   "MAGNESIUM" - Value representing magnesium nutrient.
	//   "MANGANESE" - Value representing manganese nutrient.
	//   "MOLYBDENUM" - Value representing molybdenum nutrient.
	//   "MONOUNSATURATED_FAT" - Value representing monounsaturated fat nutrient.
	//   "NIACIN" - Value representing niacin nutrient.
	//   "PANTOTHENIC_ACID" - Value representing pantothenic acid nutrient.
	//   "PHOSPHORUS" - Value representing phosphorus nutrient.
	//   "POLYUNSATURATED_FAT" - Value representing polyunsaturated fat nutrient.
	//   "POTASSIUM" - Value representing potassium nutrient.
	//   "PROTEIN" - Value representing protein nutrient.
	//   "RIBOFLAVIN" - Value representing riboflavin nutrient.
	//   "SATURATED_FAT" - Value representing saturated fat nutrient.
	//   "SELENIUM" - Value representing selenium nutrient.
	//   "SODIUM" - Value representing sodium nutrient.
	//   "SUGAR" - Value representing sugar nutrient.
	//   "THIAMIN" - Value representing thiamin nutrient.
	//   "TRANS_FAT" - Value representing trans fat nutrient.
	//   "UNSATURATED_FAT" - Value representing unsaturated fat nutrient.
	//   "VITAMIN_A" - Value representing vitamin A nutrient.
	//   "VITAMIN_B12" - Value representing vitamin B12 nutrient.
	//   "VITAMIN_B6" - Value representing vitamin B6 nutrient.
	//   "VITAMIN_C" - Value representing vitamin C nutrient.
	//   "VITAMIN_D" - Value representing vitamin D nutrient.
	//   "VITAMIN_E" - Value representing vitamin E nutrient.
	//   "VITAMIN_K" - Value representing vitamin K nutrient.
	//   "ZINC" - Value representing zinc nutrient.
	//   "FOLATE" - Value representing folate nutrient.
	Nutrient string `json:"nutrient,omitempty"`
	// Quantity: Required. Aggregated nutrient weight.
	Quantity *WeightQuantityRollup `json:"quantity,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Nutrient") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Nutrient") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s NutrientQuantityRollup) MarshalJSON() ([]byte, error) {
	type NoMethod NutrientQuantityRollup
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// NutritionLog: Holds information about food logged by a user. There are two
// ways of creating a nutrition log based on the food type: 1. Identified food:
// Using the food field, which is a reference to a Food resource. In this case
// fields `nutrients`, `energy`, `energy_from_fat`, `total_carbohydrate`,
// `total_fat`, `food_display_name` will be populated based on the referenced
// food. 2. Anonymous food: Using the `food_display_name` field and setting the
// `nutrients`, `energy`, `energy_from_fat`, `total_carbohydrate`, `total_fat`
// fields manually. The identified food is preferred over the anonymous food.
// Nutrition logs created from anonymous food are not editable.
type NutritionLog struct {
	// Energy: Optional. The total energy of the food, measured in kilocalories
	// (`kcal`).
	Energy *EnergyQuantity `json:"energy,omitempty"`
	// EnergyFromFat: Optional. The energy from fat, measured in kilocalories
	// (`kcal`).
	EnergyFromFat *EnergyQuantity `json:"energyFromFat,omitempty"`
	// Food: Optional. The resource name of the Food item. Required when creating a
	// nutrition log from an identified food. For anonymous food logs, use the
	// `food_display_name` field instead.
	Food string `json:"food,omitempty"`
	// FoodDisplayName: The display name of the food. For identified food logs,
	// this is populated automatically from the referenced food.
	FoodDisplayName string `json:"foodDisplayName,omitempty"`
	// Interval: Required. The time window when the food was logged.
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// MealType: Optional. The meal category. One of `BREAKFAST`, `LUNCH`,
	// `DINNER`, or `SNACK`.
	//
	// Possible values:
	//   "MEAL_TYPE_UNSPECIFIED" - Unspecified meal type.
	//   "BEFORE_BREAKFAST" - Value representing a meal before breakfast.
	//   "BREAKFAST" - Value representing a breakfast.
	//   "BEFORE_LUNCH" - Value representing a morning snack.
	//   "LUNCH" - Value representing a lunch.
	//   "BEFORE_DINNER" - Value representing an afternoon snack.
	//   "DINNER" - Value representing dinner.
	//   "AFTER_DINNER" - Value representing an evening snack.
	//   "SNACK" - Value representing any meal outside of the usual three meals per
	// day.
	//   "ANYTIME" - Value representing any time (legacy NA).
	MealType string `json:"mealType,omitempty"`
	// Nutrients: Optional. An array of individual nutrient values for the
	// nutrition log.
	Nutrients []*NutrientQuantity `json:"nutrients,omitempty"`
	// Serving: Optional. The serving information for the logged food.
	Serving *Serving `json:"serving,omitempty"`
	// TotalCarbohydrate: Optional. The total carbohydrate content, measured in
	// grams.
	TotalCarbohydrate *WeightQuantity `json:"totalCarbohydrate,omitempty"`
	// TotalFat: Optional. The total fat content, measured in grams.
	TotalFat *WeightQuantity `json:"totalFat,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Energy") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Energy") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s NutritionLog) MarshalJSON() ([]byte, error) {
	type NoMethod NutritionLog
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// NutritionLogRollupValue: Represents the result of the rollup of the
// nutrition log data type.
type NutritionLogRollupValue struct {
	// Energy: Energy rollup.
	Energy *EnergyQuantityRollup `json:"energy,omitempty"`
	// EnergyFromFat: Value Energy from fat rollup.
	EnergyFromFat *EnergyQuantityRollup `json:"energyFromFat,omitempty"`
	// Nutrients: List of the nutrient roll-ups by the nutrient type.
	Nutrients []*NutrientQuantityRollup `json:"nutrients,omitempty"`
	// TotalCarbohydrate: Total carbohydrate rollup.
	TotalCarbohydrate *WeightQuantityRollup `json:"totalCarbohydrate,omitempty"`
	// TotalFat: Total fat rollup.
	TotalFat *WeightQuantityRollup `json:"totalFat,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Energy") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Energy") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s NutritionLogRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod NutritionLogRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ObservationSampleTime: Represents a sample time of an observed data point.
type ObservationSampleTime struct {
	// CivilTime: Output only. The civil time in the timezone the subject is in at
	// the time of the observation.
	CivilTime *CivilDateTime `json:"civilTime,omitempty"`
	// PhysicalTime: Required. The time of the observation.
	PhysicalTime string `json:"physicalTime,omitempty"`
	// UtcOffset: Required. The offset of the user's local time during the
	// observation relative to the Coordinated Universal Time (UTC).
	UtcOffset string `json:"utcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CivilTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CivilTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ObservationSampleTime) MarshalJSON() ([]byte, error) {
	type NoMethod ObservationSampleTime
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ObservationTimeInterval: Represents a time interval of an observed data
// point.
type ObservationTimeInterval struct {
	// CivilEndTime: Output only. Observed interval end time in civil time in the
	// timezone the subject is in at the end of the observed interval
	CivilEndTime *CivilDateTime `json:"civilEndTime,omitempty"`
	// CivilStartTime: Output only. Observed interval start time in civil time in
	// the timezone the subject is in at the start of the observed interval
	CivilStartTime *CivilDateTime `json:"civilStartTime,omitempty"`
	// EndTime: Required. Observed interval end time.
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. The offset of the user's local time at the end of
	// the observation relative to the Coordinated Universal Time (UTC).
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// StartTime: Required. Observed interval start time.
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. The offset of the user's local time at the start
	// of the observation relative to the Coordinated Universal Time (UTC).
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CivilEndTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CivilEndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ObservationTimeInterval) MarshalJSON() ([]byte, error) {
	type NoMethod ObservationTimeInterval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Done") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Done") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Operation) MarshalJSON() ([]byte, error) {
	type NoMethod Operation
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// OutOfBedSegment: A time interval to represent an out-of-bed segment.
type OutOfBedSegment struct {
	// EndTime: Required. Segment end time.
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. The offset of the user's local time at the end of
	// the segment relative to the Coordinated Universal Time (UTC).
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// StartTime: Required. Segment tart time.
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. The offset of the user's local time at the start
	// of the segment relative to the Coordinated Universal Time (UTC).
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EndTime") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s OutOfBedSegment) MarshalJSON() ([]byte, error) {
	type NoMethod OutOfBedSegment
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// OvulationTest: Ovulation test record.
type OvulationTest struct {
	// Result: Required. The result of the ovulation test.
	//
	// Possible values:
	//   "OVULATION_TEST_RESULT_UNSPECIFIED" - Unspecified result.
	//   "NEGATIVE" - Negative result.
	//   "LUTEINIZING_HORMONE_SURGE" - Luteinizing hormone surge.
	//   "ESTROGEN_SURGE" - Estrogen surge.
	//   "POSITIVE" - Positive result.
	//   "INDETERMINATE" - Indeterminate result.
	Result string `json:"result,omitempty"`
	// SampleTime: Required. The time at which ovulation test was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Result") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Result") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s OvulationTest) MarshalJSON() ([]byte, error) {
	type NoMethod OvulationTest
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// OxygenSaturation: Captures the user's instantaneous oxygen saturation
// percentage (SpO2).
type OxygenSaturation struct {
	// Percentage: Required. The oxygen saturation percentage. Valid values are
	// from 0 to 100.
	Percentage float64 `json:"percentage,omitempty"`
	// SampleTime: Required. The time at which oxygen saturation was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Percentage") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Percentage") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s OxygenSaturation) MarshalJSON() ([]byte, error) {
	type NoMethod OxygenSaturation
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *OxygenSaturation) UnmarshalJSON(data []byte) error {
	type NoMethod OxygenSaturation
	var s1 struct {
		Percentage gensupport.JSONFloat64 `json:"percentage"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Percentage = float64(s1.Percentage)
	return nil
}

// PairedDevice: User's Paired 1P Device The PairedDevice details include
// information about the device type, battery status, battery level, last sync
// time, device version, mac address, and features.
type PairedDevice struct {
	// BatteryLevel: Output only. The battery level of the device.
	BatteryLevel int64 `json:"batteryLevel,omitempty"`
	// BatteryStatus: Output only. The battery status of the device. Supported:
	// High | Medium | Low | Empty
	BatteryStatus string `json:"batteryStatus,omitempty"`
	// DeviceType: Output only. The device type. Supported: TRACKER | SCALE
	//
	// Possible values:
	//   "DEVICE_TYPE_UNSPECIFIED" - Device type is not specified.
	//   "TRACKER" - Device type is tracker.
	//   "SCALE" - Device type is scale.
	DeviceType string `json:"deviceType,omitempty"`
	// DeviceVersion: Output only. The product name of the device
	DeviceVersion string `json:"deviceVersion,omitempty"`
	// Features: Output only. Lists of unique features supported by the device.
	// Comprehensive list of supported features: **Fitness Tracking** -
	// `ACTIVE_MINUTES`: Legacy active minutes. - `AUTOSTRIDE`: Automatic stride
	// length calculation. - `BIKE_ONBOARDING`: Cycling UI support. - `CALORIES`:
	// Daily burned calories. - `DISTANCE`: Daily distance tracking. - `ELEVATION`:
	// Floors climbed. - `INACTIVITY_ALERTS`: Reminders to move. -
	// `SEDENTARY_TIME`: Tracks inactive time. - `STEPS`: Daily steps. - `SWIM`:
	// Swim tracking (laps/strokes). - `AUTORUN`: Automatic run detection. -
	// `ACTIVE_ZONE_MINUTES`: Active Zone Minutes (AZM). **Heart Rate & Health** -
	// `HEART_RATE`: Continuous heart rate (PPG). - `BAT_SIGNAL`: High/Low Heart
	// Rate Alerts. **Advanced Sensors** - `SPO2`: Blood oxygen saturation. -
	// `NIGHTTIME_OXYGEN_SATURATION`: Sleep SpO2. - `ESTIMATED_OXYGEN_VARIATION`:
	// Estimated Oxygen Variation. - `EDA`: Electrodermal Activity (stress). -
	// `SKIN_TEMPERATURE`: Skin temperature variation. -
	// `INTERNAL_DEVICE_TEMPERATURE`: Internal device temperature. **Sleep &
	// Wellness** - `SLEEP`: Basic sleep tracking. - `SMART_SLEEP`: Advanced sleep
	// tracking (stages/score). - `BEDTIME_REMINDER`: Bedtime reminders. -
	// `SOUNDSCAPE`: Snore and noise detection. **Advanced Workouts** - `WB`:
	// Custom Workout Builder. - `AUTOCUES`: Auto Cues / Auto Lap. - `DWR_RUN`:
	// Daily Run Recommendations. - `ADVANCED_RUNNING`: Advanced Running Dynamics
	// (e.g., GCT, VO). **GPS & Location** - `GPS`: Built-in GPS. -
	// `CONNECTED_GPS`: Connected GPS (uses phone). - `LOCATION_HINT`: Location
	// helper. **Payments & NFC** - `PAYMENTS`: NFC payments (Fitbit Pay/Google
	// Wallet). - `FELICA`: FeliCa support (Japan payments/transit). **Activity
	// Detection** - `GROK`: SmartTrack automatic activity detection. - `RETRO_AR`:
	// Retroactive Activity Recognition prompts. **Smart Features & UI** -
	// `ALARMS`: Silent alarms. - `BLE_MUSIC_CONTROL`: BLE music control. -
	// `MUSIC`: Direct music storage/control. - `YOUTUBE_MUSIC_SUPPORTED`: YouTube
	// Music support. - `GALLERY`: App Gallery. - `TUTORIAL_SUPPORTED`: On-screen
	// tutorials. - `SMILEY_EMOTE`: Legacy Zip face. - `MOBILE_TO_DEVICE_DEEPLINK`:
	// Mobile to device settings deep link. - `HIDE_GALLERY`: Option to hide
	// Gallery. - `HIDE_GOAL_SELECTION`: Option to hide goal selection. -
	// `DIGITAL_WARRANTY_SUPPORTED`: Digital warranty display. -
	// `DIRECT_DEVICE_SETTINGS_SUPPORTED`: Direct device settings management. **Gym
	// HR Broadcasting** - `ASPEN_SUPPORTED`: Broadcast HR to gym equipment. -
	// `ASPEN_REMOTE_UI_SUPPORTED`: Remote UI for HR sharing. **Privacy &
	// Security** - `FINITE_IMPROBABILITY`: BLE Resolvable Private Address (RPA)
	// privacy. - `DOMAIN_KEY_SYNC`: Domain key synchronization. **BLE Protocol** -
	// `BONDING`: Secure BLE bonding. - `ADVERTISES_SERIAL`: Advertises serial
	// number. - `STATUS_CHARACTERISTIC`: BLE Status Characteristic. -
	// `TRACKER_CHANNEL_CHARACTERISTIC`: BLE Tracker Channel Characteristic. -
	// `PING_CHARACTERISTIC`: BLE Ping Characteristic. **Cellular & Wi-Fi** -
	// `MOBILE_DATA`: LTE cellular support. - `SINGLE_AP_WIFI`: Single AP Wi-Fi. -
	// `MULTI_AP_WIFI`: Multi AP Wi-Fi. - `WIFI_FWUP`: Firmware updates over Wi-Fi.
	// **Data Sync & Transfer** - `APP_SYNC`: Background app sync. - `LIVE_DATA`:
	// Real-time data streaming. - `EVENT_BASED_SYNC_SUPPORTED`: Event-based sync.
	// - `TIME_SERVICE`: Time synchronization service. - `REMOTE_FILE_PROVIDER`:
	// Remote file transfer. - `DIRECT_COMMS_ALARMS`: Direct communication for
	// alarms. - `DIRECT_COMMS_EXERCISE`: Direct communication for exercise. -
	// `DIRECT_COMMS_BATTERY_ALERTS`: Direct communication for battery alerts.
	// **Google Integrations** - `PARROT_TREE_SUPPORTED`: Find My Device support.
	Features []string `json:"features,omitempty"`
	// LastSyncTime: Output only. The time of last sync with the Fitbit mobile
	// application.
	LastSyncTime string `json:"lastSyncTime,omitempty"`
	// MacAddress: Output only. Mac ID number of the device.
	MacAddress string `json:"macAddress,omitempty"`
	// Name: Identifier. The resource name of this Device resource. Format:
	// `users/{user}/pairedDevices/{paired_device}` Example:
	// `users/1234567890/pairedDevices/123` or `users/me/pairedDevices/123`
	Name string `json:"name,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "BatteryLevel") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BatteryLevel") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PairedDevice) MarshalJSON() ([]byte, error) {
	type NoMethod PairedDevice
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Profile: Profile details.
type Profile struct {
	// Age: Optional. The age in years based on the user's birth date. Updates to
	// this field are currently not supported.
	Age int64 `json:"age,omitempty"`
	// AutoRunningStrideLengthMm: Output only. The automatically calculated running
	// stride length, in millimeters. The user must consent to the following access
	// scope to access this field: -
	// `https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly`
	AutoRunningStrideLengthMm int64 `json:"autoRunningStrideLengthMm,omitempty"`
	// AutoWalkingStrideLengthMm: Output only. The automatically calculated walking
	// stride length, in millimeters. The user must consent to the following access
	// scope to access this field: -
	// `https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly`
	AutoWalkingStrideLengthMm int64 `json:"autoWalkingStrideLengthMm,omitempty"`
	// MembershipStartDate: Output only. The date the user created their account.
	// Updates to this field are currently not supported.
	MembershipStartDate *Date `json:"membershipStartDate,omitempty"`
	// Name: Identifier. The resource name of this Profile resource. Format:
	// `users/{user}/profile` Example: `users/1234567890/profile` or
	// `users/me/profile` The {user} ID is a system-generated Google Health API
	// user ID, a string of 1-63 characters consisting of lowercase and uppercase
	// letters, numbers, and hyphens. The literal `me` can also be used to refer to
	// the authenticated user.
	Name string `json:"name,omitempty"`
	// UserConfiguredRunningStrideLengthMm: Optional. The user's user configured
	// running stride length, in millimeters. The user must consent to the
	// following access scope to access this field: -
	// `https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly`
	UserConfiguredRunningStrideLengthMm int64 `json:"userConfiguredRunningStrideLengthMm,omitempty"`
	// UserConfiguredWalkingStrideLengthMm: Optional. The user's user configured
	// walking stride length, in millimeters. The user must consent to the
	// following access scope to access this field: -
	// `https://www.googleapis.com/auth/googlehealth.activity_and_fitness.readonly`
	UserConfiguredWalkingStrideLengthMm int64 `json:"userConfiguredWalkingStrideLengthMm,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Age") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Age") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Profile) MarshalJSON() ([]byte, error) {
	type NoMethod Profile
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ReconcileDataPointsResponse: Response containing the list of reconciled
// DataPoints.
type ReconcileDataPointsResponse struct {
	// DataPoints: Data points matching the query
	DataPoints []*ReconciledDataPoint `json:"dataPoints,omitempty"`
	// NextPageToken: Next page token, empty if the response is complete
	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. "DataPoints") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataPoints") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ReconcileDataPointsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ReconcileDataPointsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ReconciledDataPoint: A reconciled computed or recorded metric.
type ReconciledDataPoint struct {
	// ActiveEnergyBurned: Data for points in the `active-energy-burned` interval
	// data type collection.
	ActiveEnergyBurned *ActiveEnergyBurned `json:"activeEnergyBurned,omitempty"`
	// ActiveMinutes: Data for points in the `active-minutes` interval data type
	// collection.
	ActiveMinutes *ActiveMinutes `json:"activeMinutes,omitempty"`
	// ActiveZoneMinutes: Data for points in the `active-zone-minutes` interval
	// data type collection, measured in minutes.
	ActiveZoneMinutes *ActiveZoneMinutes `json:"activeZoneMinutes,omitempty"`
	// ActivityLevel: Data for points in the `activity-level` daily data type
	// collection.
	ActivityLevel *ActivityLevel `json:"activityLevel,omitempty"`
	// Altitude: Data for points in the `altitude` interval data type collection.
	Altitude *Altitude `json:"altitude,omitempty"`
	// BasalEnergyBurned: Data for points in the `basal-energy-burned` interval
	// data type collection.
	BasalEnergyBurned *BasalEnergyBurned `json:"basalEnergyBurned,omitempty"`
	// BloodGlucose: Data for points in the `blood-glucose` sample data type
	// collection.
	BloodGlucose *BloodGlucose `json:"bloodGlucose,omitempty"`
	// BodyFat: Data for points in the `body-fat` sample data type collection.
	BodyFat *BodyFat `json:"bodyFat,omitempty"`
	// CoreBodyTemperature: Data for points in the `core-body-temperature` sample
	// data type collection.
	CoreBodyTemperature *CoreBodyTemperature `json:"coreBodyTemperature,omitempty"`
	// DailyHeartRateVariability: Data for points in the
	// `daily-heart-rate-variability` daily data type collection.
	DailyHeartRateVariability *DailyHeartRateVariability `json:"dailyHeartRateVariability,omitempty"`
	// DailyHeartRateZones: Data for points in the `daily-heart-rate-zones` daily
	// data type collection.
	DailyHeartRateZones *DailyHeartRateZones `json:"dailyHeartRateZones,omitempty"`
	// DailyOxygenSaturation: Data for points in the `daily-oxygen-saturation`
	// daily data type collection.
	DailyOxygenSaturation *DailyOxygenSaturation `json:"dailyOxygenSaturation,omitempty"`
	// DailyRespiratoryRate: Data for points in the `daily-respiratory-rate` daily
	// data type collection.
	DailyRespiratoryRate *DailyRespiratoryRate `json:"dailyRespiratoryRate,omitempty"`
	// DailyRestingHeartRate: Data for points in the `daily-resting-heart-rate`
	// daily data type collection.
	DailyRestingHeartRate *DailyRestingHeartRate `json:"dailyRestingHeartRate,omitempty"`
	// DailySleepTemperatureDerivations: Data for points in the
	// `daily-sleep-temperature-derivations` daily data type collection.
	DailySleepTemperatureDerivations *DailySleepTemperatureDerivations `json:"dailySleepTemperatureDerivations,omitempty"`
	// DailyVo2Max: Data for points in the `daily-vo2-max` daily data type
	// collection.
	DailyVo2Max *DailyVO2Max `json:"dailyVo2Max,omitempty"`
	// DataPointName: Identifier. Data point name, only supported for the subset of
	// identifiable data types. For the majority of the data types, individual data
	// points do not need to be identified and this field would be empty. Format:
	// `users/{user}/dataTypes/{data_type}/dataPoints/{data_point}` Example:
	// `users/abcd1234/dataTypes/sleep/dataPoints/a1b2c3d4-e5f6-7890-1234-567890abcd
	// ef` The `{user}` ID is a system-generated identifier, as described in
	// Identity.health_user_id. The `{data_type}` ID corresponds to the kebab-case
	// version of the field names in the DataPoint data union field, e.g.
	// `heart-rate` for the `heart_rate` field. The `{data_point}` ID can be
	// client-provided or system-generated. If client-provided, it must be a string
	// of 4-63 characters, containing only lowercase letters, numbers, and hyphens.
	DataPointName string `json:"dataPointName,omitempty"`
	// Distance: Data for points in the `distance` interval data type collection.
	Distance *Distance `json:"distance,omitempty"`
	// Exercise: Data for points in the `exercise` session data type collection.
	Exercise *Exercise `json:"exercise,omitempty"`
	// Floors: Data for points in the `floors` interval data type collection.
	Floors *Floors `json:"floors,omitempty"`
	// HeartRate: Data for points in the `heart-rate` sample data type collection.
	HeartRate *HeartRate `json:"heartRate,omitempty"`
	// HeartRateVariability: Data for points in the `heart-rate-variability` sample
	// data type collection.
	HeartRateVariability *HeartRateVariability `json:"heartRateVariability,omitempty"`
	// Height: Data for points in the `height` sample data type collection.
	Height *Height `json:"height,omitempty"`
	// HydrationLog: Data for points in the `hydration-log` session data type
	// collection.
	HydrationLog *HydrationLog `json:"hydrationLog,omitempty"`
	// NutritionLog: Data for points in the `nutrition-log` session data type
	// collection.
	NutritionLog *NutritionLog `json:"nutritionLog,omitempty"`
	// OxygenSaturation: Data for points in the `oxygen-saturation` sample data
	// type collection.
	OxygenSaturation *OxygenSaturation `json:"oxygenSaturation,omitempty"`
	// RespiratoryRateSleepSummary: Data for points in the
	// `respiratory-rate-sleep-summary` sample data type collection.
	RespiratoryRateSleepSummary *RespiratoryRateSleepSummary `json:"respiratoryRateSleepSummary,omitempty"`
	// RunVo2Max: Data for points in the `run-vo2-max` sample data type collection.
	RunVo2Max *RunVO2Max `json:"runVo2Max,omitempty"`
	// SedentaryPeriod: Data for points in the `sedentary-period` interval data
	// type collection.
	SedentaryPeriod *SedentaryPeriod `json:"sedentaryPeriod,omitempty"`
	// Sleep: Data for points in the `sleep` session data type collection.
	Sleep *Sleep `json:"sleep,omitempty"`
	// Steps: Data for points in the `steps` interval data type collection.
	Steps *Steps `json:"steps,omitempty"`
	// SwimLengthsData: Data for points in the `swim-lengths-data` interval data
	// type collection.
	SwimLengthsData *SwimLengthsData `json:"swimLengthsData,omitempty"`
	// TimeInHeartRateZone: Data for points in the `time-in-heart-rate-zone`
	// interval data type collection.
	TimeInHeartRateZone *TimeInHeartRateZone `json:"timeInHeartRateZone,omitempty"`
	// Vo2Max: Data for points in the `vo2-max` sample data type collection.
	Vo2Max *VO2Max `json:"vo2Max,omitempty"`
	// Weight: Data for points in the `weight` sample data type collection.
	Weight *Weight `json:"weight,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveEnergyBurned") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveEnergyBurned") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ReconciledDataPoint) MarshalJSON() ([]byte, error) {
	type NoMethod ReconciledDataPoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// RespiratoryRateSleepSummary: Records respiratory rate details during sleep.
// Can have multiple per day if the user sleeps multiple times.
type RespiratoryRateSleepSummary struct {
	// DeepSleepStats: Optional. Respiratory rate statistics for deep sleep.
	DeepSleepStats *RespiratoryRateSleepSummaryStatistics `json:"deepSleepStats,omitempty"`
	// FullSleepStats: Required. Full respiratory rate statistics.
	FullSleepStats *RespiratoryRateSleepSummaryStatistics `json:"fullSleepStats,omitempty"`
	// LightSleepStats: Optional. Respiratory rate statistics for light sleep.
	LightSleepStats *RespiratoryRateSleepSummaryStatistics `json:"lightSleepStats,omitempty"`
	// RemSleepStats: Optional. Respiratory rate statistics for REM sleep.
	RemSleepStats *RespiratoryRateSleepSummaryStatistics `json:"remSleepStats,omitempty"`
	// SampleTime: Required. The time at which respiratory rate was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DeepSleepStats") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DeepSleepStats") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RespiratoryRateSleepSummary) MarshalJSON() ([]byte, error) {
	type NoMethod RespiratoryRateSleepSummary
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// RespiratoryRateSleepSummaryStatistics: Respiratory rate statistics for a
// given sleep stage.
type RespiratoryRateSleepSummaryStatistics struct {
	// BreathsPerMinute: Required. Average breaths per minute.
	BreathsPerMinute float64 `json:"breathsPerMinute,omitempty"`
	// SignalToNoise: Optional. How trustworthy the data is for the computation.
	SignalToNoise float64 `json:"signalToNoise,omitempty"`
	// StandardDeviation: Optional. Standard deviation of the respiratory rate
	// during sleep.
	StandardDeviation float64 `json:"standardDeviation,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BreathsPerMinute") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BreathsPerMinute") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RespiratoryRateSleepSummaryStatistics) MarshalJSON() ([]byte, error) {
	type NoMethod RespiratoryRateSleepSummaryStatistics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *RespiratoryRateSleepSummaryStatistics) UnmarshalJSON(data []byte) error {
	type NoMethod RespiratoryRateSleepSummaryStatistics
	var s1 struct {
		BreathsPerMinute  gensupport.JSONFloat64 `json:"breathsPerMinute"`
		SignalToNoise     gensupport.JSONFloat64 `json:"signalToNoise"`
		StandardDeviation gensupport.JSONFloat64 `json:"standardDeviation"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BreathsPerMinute = float64(s1.BreathsPerMinute)
	s.SignalToNoise = float64(s1.SignalToNoise)
	s.StandardDeviation = float64(s1.StandardDeviation)
	return nil
}

// RestingHeartRatePersonalRangeRollupValue: Represents the rollup value for
// the daily resting heart rate data type.
type RestingHeartRatePersonalRangeRollupValue struct {
	// BeatsPerMinuteMax: The upper bound of the user's daily resting heart rate
	// personal range.
	BeatsPerMinuteMax float64 `json:"beatsPerMinuteMax,omitempty"`
	// BeatsPerMinuteMin: The lower bound of the user's daily resting heart rate
	// personal range.
	BeatsPerMinuteMin float64 `json:"beatsPerMinuteMin,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BeatsPerMinuteMax") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BeatsPerMinuteMax") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RestingHeartRatePersonalRangeRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod RestingHeartRatePersonalRangeRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *RestingHeartRatePersonalRangeRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod RestingHeartRatePersonalRangeRollupValue
	var s1 struct {
		BeatsPerMinuteMax gensupport.JSONFloat64 `json:"beatsPerMinuteMax"`
		BeatsPerMinuteMin gensupport.JSONFloat64 `json:"beatsPerMinuteMin"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.BeatsPerMinuteMax = float64(s1.BeatsPerMinuteMax)
	s.BeatsPerMinuteMin = float64(s1.BeatsPerMinuteMin)
	return nil
}

// RollUpDataPointsRequest: Request to roll up data points by physical time
// intervals.
type RollUpDataPointsRequest struct {
	// DataSourceFamily: Optional. The data source family name to roll up. If
	// empty, data points from all available data sources will be rolled up.
	// Format: `users/me/dataSourceFamilies/{data_source_family}` The supported
	// values are: - `users/me/dataSourceFamilies/all-sources` - Default value.
	// Includes data from all available data sources. -
	// `users/me/dataSourceFamilies/google-wearables` - Includes data from Google
	// and Fitbit tracker devices (such as Fitbit trackers and Pixel Watch).
	// Excludes manually logged data. -
	// `users/me/dataSourceFamilies/google-sources` - Includes first-party Google
	// data, such as data from tracker devices, manually logged data, and Health
	// Connect.
	DataSourceFamily string `json:"dataSourceFamily,omitempty"`
	// PageSize: Optional. The maximum number of data points to return. If
	// unspecified, at most 1440 data points will be returned. The maximum page
	// size is 10000; values above that will be truncated accordingly.
	PageSize int64 `json:"pageSize,omitempty"`
	// PageToken: Optional. The next_page_token from a previous request, if any.
	// All other request fields need to be the same as in the initial request when
	// the page token is specified.
	PageToken string `json:"pageToken,omitempty"`
	// Range: Required. Closed-open range of data points that will be rolled up.
	// The maximum range for `calories-in-heart-rate-zone`, `heart-rate`,
	// `active-minutes` and `total-calories` is 14 days. The maximum range for all
	// other data types is 90 days.
	Range *Interval `json:"range,omitempty"`
	// WindowSize: Required. The size of the time window to group data points into
	// before applying the aggregation functions. Must be at least 1 second. If the
	// requested range is not an exact multiple of `window_size`, the final bucket
	// chronologically will be truncated at the upper endpoint of the range and
	// will cover a duration shorter than `window_size`.
	WindowSize string `json:"windowSize,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DataSourceFamily") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataSourceFamily") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RollUpDataPointsRequest) MarshalJSON() ([]byte, error) {
	type NoMethod RollUpDataPointsRequest
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// RollUpDataPointsResponse: Response containing the list of rolled up data
// points.
type RollUpDataPointsResponse struct {
	// NextPageToken: A token, which can be sent as `page_token` to retrieve the
	// next page. If this field is omitted, there are no subsequent pages.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// RollupDataPoints: Values for each aggregation time window.
	RollupDataPoints []*RollupDataPoint `json:"rollupDataPoints,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RollUpDataPointsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod RollUpDataPointsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// RollupDataPoint: Value of a rollup for a single physical time interval
// (aggregation window) of reconciled data points from all data sources,
// excluding those data points that are identified as recorded by wearables in
// intervals when they were not actually worn.
type RollupDataPoint struct {
	// ActiveEnergyBurned: Returned by default when rolling up data points from the
	// `active-energy-burned` data type.
	ActiveEnergyBurned *ActiveEnergyBurnedRollupValue `json:"activeEnergyBurned,omitempty"`
	// ActiveMinutes: Returned by default when rolling up data points from the
	// `active-minutes` data type, or when requested explicitly using the
	// `active-minutes` rollup type identifier.
	ActiveMinutes *ActiveMinutesRollupValue `json:"activeMinutes,omitempty"`
	// ActiveZoneMinutes: Returned by default when rolling up data points from the
	// `active-zone-minutes` data type, or when requested explicitly using the
	// `active-zone-minutes` rollup type identifier.
	ActiveZoneMinutes *ActiveZoneMinutesRollupValue `json:"activeZoneMinutes,omitempty"`
	// ActivityLevel: Returned by default when rolling up data points from the
	// `activity-level` data type, or when requested explicitly using the
	// `activity-level` rollup type identifier.
	ActivityLevel *ActivityLevelRollupValue `json:"activityLevel,omitempty"`
	// Altitude: Returned by default when rolling up data points from the
	// `altitude` data type, or when requested explicitly using the `altitude`
	// rollup type identifier.
	Altitude *AltitudeRollupValue `json:"altitude,omitempty"`
	// BloodGlucose: Returned by default when rolling up data points from the
	// `blood-glucose` data type.
	BloodGlucose *BloodGlucoseRollupValue `json:"bloodGlucose,omitempty"`
	// BodyFat: Returned by default when rolling up data points from the `body-fat`
	// data type, or when requested explicitly using the `body-fat` rollup type
	// identifier.
	BodyFat *BodyFatRollupValue `json:"bodyFat,omitempty"`
	// CaloriesInHeartRateZone: Returned by default when rolling up data points
	// from the `calories-in-heart-rate-zone` data type, or when requested
	// explicitly using the `calories-in-heart-rate-zone` rollup type identifier.
	CaloriesInHeartRateZone *CaloriesInHeartRateZoneRollupValue `json:"caloriesInHeartRateZone,omitempty"`
	// CoreBodyTemperature: Returned by default when rolling up data points from
	// the `core-body-temperature` data type, or when requested explicitly using
	// the `core-body-temperature` rollup type identifier.
	CoreBodyTemperature *CoreBodyTemperatureRollupValue `json:"coreBodyTemperature,omitempty"`
	// Distance: Returned by default when rolling up data points from the
	// `distance` data type, or when requested explicitly using the `distance`
	// rollup type identifier.
	Distance *DistanceRollupValue `json:"distance,omitempty"`
	// EndTime: End time of the window this value aggregates over
	EndTime string `json:"endTime,omitempty"`
	// Floors: Returned by default when rolling up data points from the `floors`
	// data type, or when requested explicitly using the `floors` rollup type
	// identifier.
	Floors *FloorsRollupValue `json:"floors,omitempty"`
	// HeartRate: Returned by default when rolling up data points from the
	// `heart-rate` data type, or when requested explicitly using the `heart-rate`
	// rollup type identifier.
	HeartRate *HeartRateRollupValue `json:"heartRate,omitempty"`
	// HydrationLog: Returned by default when rolling up data points from the
	// `hydration-log` data type, or when requested explicitly using the
	// `hydration-log` rollup type identifier.
	HydrationLog *HydrationLogRollupValue `json:"hydrationLog,omitempty"`
	// NutritionLog: Returned by default when rolling up data points from the
	// `nutrition-log` data type, or when requested explicitly using the
	// `nutrition-log` rollup type identifier.
	NutritionLog *NutritionLogRollupValue `json:"nutritionLog,omitempty"`
	// RunVo2Max: Returned by default when rolling up data points from the
	// `run-vo2-max` data type, or when requested explicitly using the
	// `run-vo2-max` rollup type identifier.
	RunVo2Max *RunVO2MaxRollupValue `json:"runVo2Max,omitempty"`
	// SedentaryPeriod: Returned by default when rolling up data points from the
	// `sedentary-period` data type, or when requested explicitly using the
	// `sedentary-period` rollup type identifier.
	SedentaryPeriod *SedentaryPeriodRollupValue `json:"sedentaryPeriod,omitempty"`
	// StartTime: Start time of the window this value aggregates over
	StartTime string `json:"startTime,omitempty"`
	// Steps: Returned by default when rolling up data points from the `steps` data
	// type, or when requested explicitly using the `steps` rollup type identifier.
	Steps *StepsRollupValue `json:"steps,omitempty"`
	// SwimLengthsData: Returned by default when rolling up data points from the
	// `swim-lengths-data` data type, or when requested explicitly using the
	// `swim-lengths-data` rollup type identifier.
	SwimLengthsData *SwimLengthsDataRollupValue `json:"swimLengthsData,omitempty"`
	// TimeInHeartRateZone: Returned by default when rolling up data points from
	// the `time-in-heart-rate-zone` data type, or when requested explicitly using
	// the `time-in-heart-rate-zone` rollup type identifier.
	TimeInHeartRateZone *TimeInHeartRateZoneRollupValue `json:"timeInHeartRateZone,omitempty"`
	// TotalCalories: Returned by default when rolling up data points from the
	// `total-calories` data type, or when requested explicitly using the
	// `total-calories` rollup type identifier.
	TotalCalories *TotalCaloriesRollupValue `json:"totalCalories,omitempty"`
	// Weight: Returned by default when rolling up data points from the `weight`
	// data type, or when requested explicitly using the `weight` rollup type
	// identifier.
	Weight *WeightRollupValue `json:"weight,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveEnergyBurned") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveEnergyBurned") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RollupDataPoint) MarshalJSON() ([]byte, error) {
	type NoMethod RollupDataPoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// RunVO2Max: VO2 max value calculated based on the user's running activity.
// Value stored in ml/kg/min.
type RunVO2Max struct {
	// RunVo2Max: Required. Run VO2 max value in ml/kg/min.
	RunVo2Max float64 `json:"runVo2Max,omitempty"`
	// SampleTime: Required. The time at which the metric was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "RunVo2Max") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RunVo2Max") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RunVO2Max) MarshalJSON() ([]byte, error) {
	type NoMethod RunVO2Max
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *RunVO2Max) UnmarshalJSON(data []byte) error {
	type NoMethod RunVO2Max
	var s1 struct {
		RunVo2Max gensupport.JSONFloat64 `json:"runVo2Max"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.RunVo2Max = float64(s1.RunVo2Max)
	return nil
}

// RunVO2MaxRollupValue: Represents the result of the rollup of the user's
// daily heart rate variability personal range.
type RunVO2MaxRollupValue struct {
	// RateAvg: Average value of run VO2 max in the interval.
	RateAvg float64 `json:"rateAvg,omitempty"`
	// RateMax: Maximum value of run VO2 max in the interval.
	RateMax float64 `json:"rateMax,omitempty"`
	// RateMin: Minimum value of run VO2 max in the interval..
	RateMin float64 `json:"rateMin,omitempty"`
	// ForceSendFields is a list of field names (e.g. "RateAvg") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RateAvg") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RunVO2MaxRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod RunVO2MaxRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *RunVO2MaxRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod RunVO2MaxRollupValue
	var s1 struct {
		RateAvg gensupport.JSONFloat64 `json:"rateAvg"`
		RateMax gensupport.JSONFloat64 `json:"rateMax"`
		RateMin gensupport.JSONFloat64 `json:"rateMin"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.RateAvg = float64(s1.RateAvg)
	s.RateMax = float64(s1.RateMax)
	s.RateMin = float64(s1.RateMin)
	return nil
}

// SedentaryPeriod: SedentaryPeriod SedentaryPeriod data represents the periods
// of time that the user was sedentary (i.e. not moving while wearing the
// device).
type SedentaryPeriod struct {
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SedentaryPeriod) MarshalJSON() ([]byte, error) {
	type NoMethod SedentaryPeriod
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SedentaryPeriodRollupValue: Represents the result of the rollup of the
// user's sedentary periods.
type SedentaryPeriodRollupValue struct {
	// DurationSum: The total time user spent sedentary during the interval.
	DurationSum string `json:"durationSum,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DurationSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DurationSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SedentaryPeriodRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod SedentaryPeriodRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Serving: Represents different properties and information about the serving
// of a specific food.
type Serving struct {
	// Amount: Optional. The number of servings.
	Amount float64 `json:"amount,omitempty"`
	// FoodMeasurementUnit: Required. Food measurement unit
	FoodMeasurementUnit string `json:"foodMeasurementUnit,omitempty"`
	// FoodMeasurementUnitDisplayName: Output only. Legacy measurement unit for
	// serving size in singular form (e.g. "piece", "gram").
	FoodMeasurementUnitDisplayName string `json:"foodMeasurementUnitDisplayName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Amount") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Amount") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Serving) MarshalJSON() ([]byte, error) {
	type NoMethod Serving
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *Serving) UnmarshalJSON(data []byte) error {
	type NoMethod Serving
	var s1 struct {
		Amount gensupport.JSONFloat64 `json:"amount"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Amount = float64(s1.Amount)
	return nil
}

// SessionTimeInterval: Represents a time interval of session data point, which
// bundles multiple observed metrics together.
type SessionTimeInterval struct {
	// CivilEndTime: Output only. Session end time in civil time in the timezone
	// the subject is in at the end of the session.
	CivilEndTime *CivilDateTime `json:"civilEndTime,omitempty"`
	// CivilStartTime: Output only. Session start time in civil time in the
	// timezone the subject is in at the start of the session.
	CivilStartTime *CivilDateTime `json:"civilStartTime,omitempty"`
	// EndTime: Required. The end time of the observed session.
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. The offset of the user's local time at the end of
	// the session relative to the Coordinated Universal Time (UTC).
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// StartTime: Required. The start time of the observed session.
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. The offset of the user's local time at the start
	// of the session relative to the Coordinated Universal Time (UTC).
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CivilEndTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CivilEndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SessionTimeInterval) MarshalJSON() ([]byte, error) {
	type NoMethod SessionTimeInterval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Settings: Settings details.
type Settings struct {
	// AutoStrideEnabled: Optional. True if the user's stride length is determined
	// automatically. Updates to this field are currently not supported.
	AutoStrideEnabled bool `json:"autoStrideEnabled,omitempty"`
	// DistanceUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "DISTANCE_UNIT_UNSPECIFIED" - Distance unit is not specified.
	//   "DISTANCE_UNIT_MILES" - Distance unit is miles.
	//   "DISTANCE_UNIT_KILOMETERS" - Distance unit is kilometers.
	DistanceUnit string `json:"distanceUnit,omitempty"`
	// FoodLanguageCode: Output only. The food language code derived from the
	// user's food database. Possible values: `'en-US'`, `'en-GB'`, `'de-DE'`,
	// `'es-ES'`, `'fr-FR'`, `'zh-CN'`, `'zh-TW'`, `'ja-JP'`, `'en-AU'`, `'en-CA'`,
	// `'it-IT'`, `'ko-KR'`, `'es-MX'`, `'en-IN'`, `'en-SG'`, `'en-PH'`, `'en-IE'`,
	// `'fr-CA'`. Updates to this field are currently not supported.
	FoodLanguageCode string `json:"foodLanguageCode,omitempty"`
	// GlucoseUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "GLUCOSE_UNIT_UNSPECIFIED" - Glucose unit is not specified.
	//   "GLUCOSE_UNIT_MG_DL" - Glucose unit is mg/dL.
	//   "GLUCOSE_UNIT_MMOL_L" - Glucose unit is mmol/l.
	GlucoseUnit string `json:"glucoseUnit,omitempty"`
	// HeightUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "HEIGHT_UNIT_UNSPECIFIED" - Height unit is not specified.
	//   "HEIGHT_UNIT_INCHES" - Height unit is inches.
	//   "HEIGHT_UNIT_CENTIMETERS" - Height unit is cm.
	HeightUnit string `json:"heightUnit,omitempty"`
	// LanguageLocale: Optional. The locale defined in the user's account settings.
	// Updates to this field are currently not supported.
	LanguageLocale string `json:"languageLocale,omitempty"`
	// Name: Identifier. The resource name of this Settings resource. Format:
	// `users/{user}/settings` Example: `users/1234567890/settings` or
	// `users/me/settings` The {user} ID is a system-generated Google Health API
	// user ID, a string of 1-63 characters consisting of lowercase and uppercase
	// letters, numbers, and hyphens. The literal `me` can also be used to refer to
	// the authenticated user.
	Name string `json:"name,omitempty"`
	// StrideLengthRunningType: Optional. The stride length type defined in the
	// user's account settings for running. Updates to this field are currently not
	// supported.
	//
	// Possible values:
	//   "STRIDE_LENGTH_TYPE_UNSPECIFIED" - Stride length type is not specified.
	//   "STRIDE_LENGTH_TYPE_DEFAULT" - Stride length type is computed based on the
	// user's gender and height.
	//   "STRIDE_LENGTH_TYPE_MANUAL" - Stride length type is manually set by the
	// user.
	//   "STRIDE_LENGTH_TYPE_AUTO" - Stride length type is determined
	// automatically.
	StrideLengthRunningType string `json:"strideLengthRunningType,omitempty"`
	// StrideLengthWalkingType: Optional. The stride length type defined in the
	// user's account settings for walking. Updates to this field are currently not
	// supported.
	//
	// Possible values:
	//   "STRIDE_LENGTH_TYPE_UNSPECIFIED" - Stride length type is not specified.
	//   "STRIDE_LENGTH_TYPE_DEFAULT" - Stride length type is computed based on the
	// user's gender and height.
	//   "STRIDE_LENGTH_TYPE_MANUAL" - Stride length type is manually set by the
	// user.
	//   "STRIDE_LENGTH_TYPE_AUTO" - Stride length type is determined
	// automatically.
	StrideLengthWalkingType string `json:"strideLengthWalkingType,omitempty"`
	// SwimUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "SWIM_UNIT_UNSPECIFIED" - Swim unit is not specified.
	//   "SWIM_UNIT_METERS" - Swim unit is meters.
	//   "SWIM_UNIT_YARDS" - Swim unit is yards.
	SwimUnit string `json:"swimUnit,omitempty"`
	// TemperatureUnit: Optional. The measurement unit defined in the user's
	// account settings.
	//
	// Possible values:
	//   "TEMPERATURE_UNIT_UNSPECIFIED" - Temperature unit is not specified.
	//   "TEMPERATURE_UNIT_CELSIUS" - Temperature unit is Celsius.
	//   "TEMPERATURE_UNIT_FAHRENHEIT" - Temperature unit is Fahrenheit.
	TemperatureUnit string `json:"temperatureUnit,omitempty"`
	// TimeZone: Optional. The timezone defined in the user's account settings.
	// This follows the IANA Time Zone Database (https://www.iana.org/time-zones).
	// Updates to this field are currently not supported.
	TimeZone string `json:"timeZone,omitempty"`
	// UtcOffset: Optional. The user's timezone offset relative to UTC. Updates to
	// this field are currently not supported.
	UtcOffset string `json:"utcOffset,omitempty"`
	// WaterUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "WATER_UNIT_UNSPECIFIED" - Water unit is not specified.
	//   "WATER_UNIT_ML" - Water unit is milliliters.
	//   "WATER_UNIT_FL_OZ" - Water unit is fluid ounces.
	//   "WATER_UNIT_CUP" - Water unit is cups.
	WaterUnit string `json:"waterUnit,omitempty"`
	// WeightUnit: Optional. The measurement unit defined in the user's account
	// settings.
	//
	// Possible values:
	//   "WEIGHT_UNIT_UNSPECIFIED" - Weight unit is not specified.
	//   "WEIGHT_UNIT_POUNDS" - Weight unit is pounds.
	//   "WEIGHT_UNIT_STONE" - Weight unit is stones.
	//   "WEIGHT_UNIT_KILOGRAMS" - Weight unit is kilograms.
	WeightUnit string `json:"weightUnit,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "AutoStrideEnabled") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AutoStrideEnabled") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Settings) MarshalJSON() ([]byte, error) {
	type NoMethod Settings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Sleep: A sleep session possibly including stages.
type Sleep struct {
	// CreateTime: Output only. Creation time of this sleep observation.
	CreateTime string `json:"createTime,omitempty"`
	// Interval: Required. Observed sleep interval.
	Interval *SessionTimeInterval `json:"interval,omitempty"`
	// Metadata: Optional. Sleep metadata: `processed`, `main_sleep`,
	// `manually_edited`, and `stages_status`.
	Metadata *SleepMetadata `json:"metadata,omitempty"`
	// OutOfBedSegments: Optional. “Out of bed” segments that can overlap with
	// sleep stages.
	OutOfBedSegments []*OutOfBedSegment `json:"outOfBedSegments,omitempty"`
	// ShortAwakenings: Output only. List of short awake segments (under a set
	// threshold) that are part of the sleep session. These can overlap with sleep
	// stages.
	ShortAwakenings []*SleepStage `json:"shortAwakenings,omitempty"`
	// Stages: Optional. List of non-overlapping contiguous sleep stage segments
	// that cover the sleep period.
	Stages []*SleepStage `json:"stages,omitempty"`
	// Summary: Output only. Sleep summary: metrics and stages summary.
	Summary *SleepSummary `json:"summary,omitempty"`
	// Type: Optional. SleepType: classic or stages.
	//
	// Possible values:
	//   "SLEEP_TYPE_UNSPECIFIED" - Sleep type is unspecified.
	//   "CLASSIC" - Classic sleep is a sleep with 3 stages types: AWAKE, RESTLESS
	// and ASLEEP.
	//   "STAGES" - On top of "classic" sleep stages an additional processing pass
	// can calculate stages more precisely, overwriting the prior stages with
	// AWAKE, LIGHT, REM and DEEP.
	Type string `json:"type,omitempty"`
	// UpdateTime: Output only. Last update time of this sleep observation.
	UpdateTime string `json:"updateTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CreateTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CreateTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Sleep) MarshalJSON() ([]byte, error) {
	type NoMethod Sleep
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SleepMetadata: Additional information about how the sleep was processed.
type SleepMetadata struct {
	// ExternalId: Optional. Sleep identifier relevant in the context of the data
	// source.
	ExternalId string `json:"externalId,omitempty"`
	// MainSleep: Output only. `main_sleep`: the longest sleep session with stages
	// within one day. If no sleep session has stages, then the longest sleep is
	// the `main_sleep`. If there are multiple days of sleep in the response, there
	// is one `main_sleep` per day.
	MainSleep bool `json:"mainSleep,omitempty"`
	// ManuallyEdited: Output only. Some sleeps autodetected by algorithms can be
	// manually edited by users.
	ManuallyEdited bool `json:"manuallyEdited,omitempty"`
	// Nap: Output only. Naps are sleeps without stages and relatively short
	// durations.
	Nap bool `json:"nap,omitempty"`
	// Processed: Output only. Sleep and sleep stages algorithms finished
	// processing. A `true` value indicates whether all data processing for the
	// session is complete. A `false` value means sleep period is detected but
	// sleep stages is still processing.
	Processed bool `json:"processed,omitempty"`
	// StagesStatus: Output only. Sleep stages algorithm processing status.
	//
	// Possible values:
	//   "STAGES_STATE_UNSPECIFIED" - Output only. Sleep stages status is
	// unspecified.
	//   "REJECTED_COVERAGE" - Output only. Sleep stages cannot be computed due to
	// low RR coverage.
	//   "REJECTED_MAX_GAP" - Output only. Sleep stages cannot be computed due to
	// the large middle gap (2h).
	//   "REJECTED_START_GAP" - Output only. Sleep stages cannot be computed due to
	// the large start gap (1h).
	//   "REJECTED_END_GAP" - Output only. Sleep stages cannot be computed due to
	// the large end gap (1h).
	//   "REJECTED_NAP" - Output only. Sleep stages cannot be computed because the
	// sleep log is a nap (has < 3h duration).
	//   "REJECTED_SERVER" - Output only. Sleep stages cannot be computed because
	// input data is not available (PPGV2, wake magnitude, etc).
	//   "TIMEOUT" - Output only. Sleep stages cannot be computed due to server
	// timeout.
	//   "SUCCEEDED" - Output only. Sleep stages successfully computed.
	//   "PROCESSING_INTERNAL_ERROR" - Output only. Sleep stages cannot be computed
	// due to server internal error.
	StagesStatus string `json:"stagesStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ExternalId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ExternalId") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SleepMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod SleepMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SleepStage: Sleep stage segment.
type SleepStage struct {
	// CreateTime: Output only. Creation time of this sleep stages segment.
	CreateTime string `json:"createTime,omitempty"`
	// EndTime: Required. Sleep stage end time.
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. The offset of the user's local time at the end of
	// the sleep stage relative to the Coordinated Universal Time (UTC).
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// StartTime: Required. Sleep stage start time.
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. The offset of the user's local time at the start
	// of the sleep stage relative to the Coordinated Universal Time (UTC).
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// Type: Required. Sleep stage type: AWAKE, DEEP, REM, LIGHT etc.
	//
	// Possible values:
	//   "SLEEP_STAGE_TYPE_UNSPECIFIED" - The default unset value.
	//   "AWAKE" - Sleep stage AWAKE.
	//   "LIGHT" - Sleep stage LIGHT.
	//   "DEEP" - Sleep stage DEEP.
	//   "REM" - Sleep stage REM.
	//   "ASLEEP" - Sleep stage ASLEEP.
	//   "RESTLESS" - Sleep stage RESTLESS.
	Type string `json:"type,omitempty"`
	// UpdateTime: Output only. Last update time of this sleep stages segment.
	UpdateTime string `json:"updateTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CreateTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CreateTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SleepStage) MarshalJSON() ([]byte, error) {
	type NoMethod SleepStage
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SleepSummary:  Sleep summary: metrics and stages summary.
type SleepSummary struct {
	// MinutesAfterWakeUp: Output only. Minutes after wake up calculated by
	// restlessness algorithm.
	MinutesAfterWakeUp int64 `json:"minutesAfterWakeUp,omitempty,string"`
	// MinutesAsleep: Output only. Total number of minutes asleep. For classic
	// sleep it is the sum of ASLEEP stages (excluding AWAKE and RESTLESS). For
	// "stages" sleep it is the sum of LIGHT, REM and DEEP stages (excluding
	// AWAKE).
	MinutesAsleep int64 `json:"minutesAsleep,omitempty,string"`
	// MinutesAwake: Output only. Total number of minutes awake. It is a sum of all
	// AWAKE stages.
	MinutesAwake int64 `json:"minutesAwake,omitempty,string"`
	// MinutesInSleepPeriod: Output only. Delta between wake time and bedtime. It
	// is the sum of all stages.
	MinutesInSleepPeriod int64 `json:"minutesInSleepPeriod,omitempty,string"`
	// MinutesToFallAsleep: Output only. Minutes to fall asleep calculated by
	// restlessness algorithm.
	MinutesToFallAsleep int64 `json:"minutesToFallAsleep,omitempty,string"`
	// StagesSummary: Output only. List of summaries (total duration and segment
	// count) per each sleep stage type.
	StagesSummary []*StageSummary `json:"stagesSummary,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MinutesAfterWakeUp") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MinutesAfterWakeUp") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SleepSummary) MarshalJSON() ([]byte, error) {
	type NoMethod SleepSummary
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SplitSummary: Represents splits or laps recorded within an exercise. Lap
// events partition a workout into segments based on criteria like distance,
// time, or calories.
type SplitSummary struct {
	// ActiveDuration: Output only. Lap time excluding the pauses.
	ActiveDuration string `json:"activeDuration,omitempty"`
	// EndTime: Required. Lap end time
	EndTime string `json:"endTime,omitempty"`
	// EndUtcOffset: Required. Lap end time offset from UTC
	EndUtcOffset string `json:"endUtcOffset,omitempty"`
	// MetricsSummary: Required. Summary metrics for this split.
	MetricsSummary *MetricsSummary `json:"metricsSummary,omitempty"`
	// SplitType: Required. Method used to split the exercise laps. Users may
	// manually mark the lap as complete even if the tracking is automatic.
	//
	// Possible values:
	//   "SPLIT_TYPE_UNSPECIFIED" - Split type is unspecified.
	//   "MANUAL" - Manual split.
	//   "DURATION" - Split by duration.
	//   "DISTANCE" - Split by distance.
	//   "CALORIES" - Split by calories.
	SplitType string `json:"splitType,omitempty"`
	// StartTime: Required. Lap start time
	StartTime string `json:"startTime,omitempty"`
	// StartUtcOffset: Required. Lap start time offset from UTC
	StartUtcOffset string `json:"startUtcOffset,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveDuration") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveDuration") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SplitSummary) MarshalJSON() ([]byte, error) {
	type NoMethod SplitSummary
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// StageSummary: Total duration and segment count for a stage.
type StageSummary struct {
	// Count: Output only. Number of sleep stages segments.
	Count int64 `json:"count,omitempty,string"`
	// Minutes: Output only. Total duration in minutes of a sleep stage.
	Minutes int64 `json:"minutes,omitempty,string"`
	// Type: Output only. Sleep stage type: AWAKE, DEEP, REM, LIGHT etc.
	//
	// Possible values:
	//   "SLEEP_STAGE_TYPE_UNSPECIFIED" - The default unset value.
	//   "AWAKE" - Sleep stage AWAKE.
	//   "LIGHT" - Sleep stage LIGHT.
	//   "DEEP" - Sleep stage DEEP.
	//   "REM" - Sleep stage REM.
	//   "ASLEEP" - Sleep stage ASLEEP.
	//   "RESTLESS" - Sleep stage RESTLESS.
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Count") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Count") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s StageSummary) MarshalJSON() ([]byte, error) {
	type NoMethod StageSummary
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Status: The `Status` type defines a logical error model that is suitable for
// different programming environments, including REST APIs and RPC APIs. It is
// used by gRPC (https://github.com/grpc). Each `Status` message contains three
// pieces of data: error code, error message, and error details. You can find
// out more about this error model and how to work with it in the API Design
// Guide (https://cloud.google.com/apis/design/errors).
type Status struct {
	// Code: The status code, which should be an enum value of google.rpc.Code.
	Code int64 `json:"code,omitempty"`
	// Details: A list of messages that carry the error details. There is a common
	// set of message types for APIs to use.
	Details []googleapi.RawMessage `json:"details,omitempty"`
	// Message: A developer-facing error message, which should be in English. Any
	// user-facing error message should be localized and sent in the
	// google.rpc.Status.details field, or localized by the client.
	Message string `json:"message,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Code") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Code") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Status) MarshalJSON() ([]byte, error) {
	type NoMethod Status
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Steps: Step count over the time interval.
type Steps struct {
	// Count: Required. Number of steps in the recorded interval.
	Count int64 `json:"count,omitempty,string"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Count") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Count") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Steps) MarshalJSON() ([]byte, error) {
	type NoMethod Steps
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// StepsRollupValue: Represents the result of the rollup of the steps data
// type.
type StepsRollupValue struct {
	// CountSum: Total number of steps in the interval.
	CountSum int64 `json:"countSum,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "CountSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CountSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s StepsRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod StepsRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Subscriber: -- Resource Messages -- A subscriber receives notifications from
// Google Health API.
type Subscriber struct {
	// CreateTime: Output only. The time at which the subscriber was created.
	CreateTime string `json:"createTime,omitempty"`
	// EndpointAuthorization: Required. Authorization mechanism for a subscriber
	// endpoint. This is required to ensure the endpoint can be verified.
	EndpointAuthorization *EndpointAuthorization `json:"endpointAuthorization,omitempty"`
	// EndpointUri: Required. The full HTTPS URI where update notifications will be
	// sent. The URI must be a valid URL and use HTTPS as the scheme. This endpoint
	// will be verified during CreateSubscriber and UpdateSubscriber calls. See RPC
	// documentation for verification details.
	EndpointUri string `json:"endpointUri,omitempty"`
	// Name: Identifier. The resource name of the Subscriber. Format:
	// projects/{project}/subscribers/{subscriber} The {project} ID is a Google
	// Cloud Project ID or Project Number. The {subscriber} ID is user-settable
	// (4-36 characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) if provided
	// during creation, or system-generated otherwise (e.g., a UUID). Example
	// (User-settable subscriber ID): projects/my-project/subscribers/my-sub-123
	// Example (System-generated subscriber ID):
	// projects/my-project/subscribers/a1b2c3d4-e5f6-7890-1234-567890abcdef
	Name string `json:"name,omitempty"`
	// State: Output only. The state of the subscriber.
	//
	// Possible values:
	//   "STATE_UNSPECIFIED" - Represents an unspecified subscriber state.
	//   "UNVERIFIED" - Represents an unverified subscriber. This is the initial
	// state of the subscriber when it is created. The backend will verify the
	// subscriber's endpoint_uri.
	//   "ACTIVE" - Represents an active subscriber. The endpoint has been
	// verified.
	//   "INACTIVE" - Represents an inactive subscriber.
	State string `json:"state,omitempty"`
	// SubscriberConfigs: Optional. Configuration for the subscriber.
	SubscriberConfigs []*SubscriberConfig `json:"subscriberConfigs,omitempty"`
	// UpdateTime: Output only. The time at which the subscriber was last updated.
	UpdateTime string `json:"updateTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CreateTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CreateTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Subscriber) MarshalJSON() ([]byte, error) {
	type NoMethod Subscriber
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SubscriberConfig: Configuration for a subscriber. A notification is sent to
// a subscription ONLY if the subscriber has a config for the data type.
type SubscriberConfig struct {
	// DataTypes: Required. See Google Health API data types
	// (https://developers.google.com/health/data-types) for the list of supported
	// data types. Values should be in kebab-case.
	DataTypes []string `json:"dataTypes,omitempty"`
	// SubscriptionCreatePolicy: Required. Policy for subscription creation.
	//
	// Possible values:
	//   "SUBSCRIPTION_CREATE_POLICY_UNSPECIFIED" - Represents an unspecified
	// policy.
	//   "AUTOMATIC" - When using `AUTOMATIC`, individual subscriptions are not
	// created or stored. Instead, eligibility for notifications is computed
	// dynamically. When a data update occurs for a given data type, notifications
	// are sent to all subscribers with an `AUTOMATIC` policy for that data type,
	// provided the user has granted the necessary consents. This means you do not
	// need to call `CreateSubscription` for each user; notifications are managed
	// automatically based on user consents. As `Subscription` resources are not
	// stored, they cannot be retrieved or managed through `GetSubscription`,
	// `ListSubscriptions`, `UpdateSubscription`, or `DeleteSubscription`.
	//   "MANUAL" - Requires subscriptions to be created manually for new users.
	// The developer needs to call CreateSubscription for new users.
	SubscriptionCreatePolicy string `json:"subscriptionCreatePolicy,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DataTypes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataTypes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SubscriberConfig) MarshalJSON() ([]byte, error) {
	type NoMethod SubscriberConfig
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Subscription: A subscription to a data collection for a specific user, to be
// delivered to a subscriber.
type Subscription struct {
	// DataTypes: Optional. Data types subscribed to. A subscriber will only
	// receive notifications for data types that are declared here. A subscription
	// can only subscribe to the data types of the subscriber. The values should be
	// in the format "users/{health_user_id}/dataTypes/{data_type}" where
	// `{data_type}` is one of "altitude", "distance", "floors", "sleep", "steps",
	// "weight".
	DataTypes []string `json:"dataTypes,omitempty"`
	// Name: Identifier. The resource name of the Subscription. Format:
	// `projects/{project}/subscribers/{subscriber}/subscriptions/{subscription}`
	// Example:
	// `projects/my-project/subscribers/my-subscriber-123/subscriptions/my-subscript
	// ion-456` The {project} ID is mandatory (6-30 characters, matching
	// /a-z{6,30}/) The {subscriber} ID is user-settable (4-36 characters, matching
	// /a-z ([a-z0-9-]{2,34}[a-z0-9])/) if provided during creation, or
	// system-generated otherwise. The {subscription} ID is user-settable (4-36
	// chars, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) or system-generated
	// otherwise.
	Name string `json:"name,omitempty"`
	// User: Immutable. The resource name of the user for whom this subscription is
	// active. Format: `users/{user}` where `{user}` is the public `healthUserId`
	// as returned by the `GetIdentity` action in the profile PAPI (see
	// `google.devicesandservices.health.v4main.HealthProfileService.GetIdentity`).
	User string `json:"user,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "DataTypes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DataTypes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Subscription) MarshalJSON() ([]byte, error) {
	type NoMethod Subscription
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SwimLengthsData: Swim lengths data over the time interval.
type SwimLengthsData struct {
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// StrokeCount: Required. Number of strokes in the lap.
	StrokeCount int64 `json:"strokeCount,omitempty,string"`
	// SwimStrokeType: Required. Swim stroke type.
	//
	// Possible values:
	//   "SWIM_STROKE_TYPE_UNSPECIFIED" - Swim stroke type is unspecified.
	//   "FREESTYLE" - Freestyle swim stroke type.
	//   "BACKSTROKE" - Backstroke swim stroke type.
	//   "BREASTSTROKE" - Breaststroke swim stroke type.
	//   "BUTTERFLY" - Butterfly swim stroke type.
	SwimStrokeType string `json:"swimStrokeType,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SwimLengthsData) MarshalJSON() ([]byte, error) {
	type NoMethod SwimLengthsData
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SwimLengthsDataRollupValue: Represents the result of the rollup of the swim
// lengths data type.
type SwimLengthsDataRollupValue struct {
	// StrokeCountSum: Total number of swim strokes in the interval.
	StrokeCountSum int64 `json:"strokeCountSum,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "StrokeCountSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "StrokeCountSum") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SwimLengthsDataRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod SwimLengthsDataRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Symptoms: Symptoms logged by the user.
type Symptoms struct {
	// SampleTime: Required. Time when the symptoms were logged.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// Symptoms: Required. List of symptoms experienced.
	//
	// Possible values:
	//   "SYMPTOM_VALUE_UNSPECIFIED" - Unspecified symptom value.
	//   "CRAMPS" - Abdominal cramps.
	//   "HEADACHE" - Headache.
	//   "TENDER_BREASTS" - Tender breasts.
	//   "ACNE" - Acne.
	//   "SICK" - Feeling sick or unwell.
	//   "BLOATED" - Bloating or abdominal swelling.
	//   "HOT_FLASHES" - Hot flashes.
	//   "PMS" - Premenstrual syndrome symptoms.
	//   "COUGH" - Coughing.
	//   "FEVER" - Fever or elevated body temperature.
	//   "DIFFICULTY_BREATHING" - Difficulty breathing or shortness of breath.
	//   "BACK_PAIN" - Back pain.
	//   "SHAKINESS" - Shakiness or tremors.
	//   "HUNGER" - Excessive hunger.
	//   "SWEATING" - Excessive sweating.
	//   "ANXIETY" - Anxiety or nervousness.
	//   "THIRST" - Excessive thirst.
	//   "FREQUENT_URINATION" - Frequent urination.
	//   "BLURRED_VISION" - Blurred vision.
	//   "OTHER" - Other symptoms.
	//   "SEX_DRIVE_HIGH" - High sex drive.
	//   "SEX_DRIVE_MEDIUM" - Medium sex drive.
	//   "SEX_DRIVE_LOW" - Low sex drive.
	//   "HEART_PALPITATIONS" - Heart palpitations or racing heart.
	//   "FAINTING" - Fainting or loss of consciousness.
	//   "CHEST_PAIN" - Chest pain or discomfort.
	//   "FATIGUE" - Fatigue or extreme tiredness.
	//   "CONFUSION" - Confusion or mental fogginess.
	//   "DIZZINESS" - Dizziness or lightheadedness.
	//   "ABDOMINAL_PAIN" - Abdominal pain.
	//   "BLADDER_LEAKS" - Bladder leaks.
	//   "BLEEDING_GUMS" - Bleeding gums.
	//   "BRAIN_FOG" - Brain fog.
	//   "BURNING_MOUTH" - Burning mouth.
	//   "CONSTIPATION" - Constipation.
	//   "CRAVINGS" - Food cravings.
	//   "DECREASED_APPETITE" - Decreased appetite.
	//   "DIARRHEA" - Diarrhea.
	//   "DRAWING_PAIN" - Drawing pain.
	//   "DRY_EYES" - Dry eyes.
	//   "DRY_HAIR" - Dry hair.
	//   "DRY_SKIN" - Dry skin.
	//   "EXHAUSTION" - Exhaustion.
	//   "FEEL_GOOD" - Feeling good or well.
	//   "FOOD_AVERSIONS" - Food aversions.
	//   "HAIR_LOSS" - Hair loss.
	//   "HEARTBURN" - Heartburn.
	//   "HYPERPIGMENTATION" - Hyperpigmentation.
	//   "INCREASED_APPETITE" - Increased appetite.
	//   "INCREASED_APPETITE_V2" - Increased appetite V2.
	//   "INSOMNIA" - Insomnia or difficulty sleeping.
	//   "JOINT_PAIN" - Joint pain.
	//   "LEG_CRAMPS" - Leg cramps.
	//   "MILKY_NIPPLE_DISCHARGE" - Milky nipple discharge.
	//   "NAUSEA" - Nausea.
	//   "NIGHT_SWEATS" - Night sweats.
	//   "NORMAL_DIGESTION" - Normal digestion.
	//   "NORMAL_STOOL" - Normal stool.
	//   "PERINEUM_PAIN" - Perineum pain.
	//   "SLEEPINESS" - Sleepiness or drowsiness.
	//   "STRETCH_MARKS" - Stretch marks.
	//   "SWELLING" - Swelling.
	//   "VAGINAL_DRYNESS" - Vaginal dryness.
	//   "VAGINAL_ITCHING" - Vaginal itching.
	//   "VOMITING" - Vomiting.
	Symptoms []string `json:"symptoms,omitempty"`
	// ForceSendFields is a list of field names (e.g. "SampleTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "SampleTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Symptoms) MarshalJSON() ([]byte, error) {
	type NoMethod Symptoms
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeInHeartRateZone: Time in heart rate zone record. It's an interval spent
// in specific heart rate zone.
type TimeInHeartRateZone struct {
	// HeartRateZoneType: Required. Heart rate zone type.
	//
	// Possible values:
	//   "HEART_RATE_ZONE_TYPE_UNSPECIFIED" - Unspecified heart rate zone.
	//   "LIGHT" - The light heart rate zone.
	//   "MODERATE" - The moderate heart rate zone.
	//   "VIGOROUS" - The vigorous heart rate zone.
	//   "PEAK" - The peak heart rate zone.
	HeartRateZoneType string `json:"heartRateZoneType,omitempty"`
	// Interval: Required. Observed interval.
	Interval *ObservationTimeInterval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HeartRateZoneType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HeartRateZoneType") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeInHeartRateZone) MarshalJSON() ([]byte, error) {
	type NoMethod TimeInHeartRateZone
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeInHeartRateZoneRollupValue: Represents the result of the rollup of the
// time in heart rate zone data type.
type TimeInHeartRateZoneRollupValue struct {
	// TimeInHeartRateZones: List of time spent in each heart rate zone.
	TimeInHeartRateZones []*TimeInHeartRateZoneValue `json:"timeInHeartRateZones,omitempty"`
	// ForceSendFields is a list of field names (e.g. "TimeInHeartRateZones") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "TimeInHeartRateZones") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeInHeartRateZoneRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod TimeInHeartRateZoneRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeInHeartRateZoneValue: Represents the total time spent in a specific
// heart rate zone.
type TimeInHeartRateZoneValue struct {
	// Duration: The total time spent in the specified heart rate zone.
	Duration string `json:"duration,omitempty"`
	// HeartRateZone: The heart rate zone.
	//
	// Possible values:
	//   "HEART_RATE_ZONE_TYPE_UNSPECIFIED" - Unspecified heart rate zone.
	//   "LIGHT" - The light heart rate zone.
	//   "MODERATE" - The moderate heart rate zone.
	//   "VIGOROUS" - The vigorous heart rate zone.
	//   "PEAK" - The peak heart rate zone.
	HeartRateZone string `json:"heartRateZone,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Duration") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Duration") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeInHeartRateZoneValue) MarshalJSON() ([]byte, error) {
	type NoMethod TimeInHeartRateZoneValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeInHeartRateZones: Time spent in each heart rate zone.
type TimeInHeartRateZones struct {
	// LightTime: Optional. Time spent in light heart rate zone.
	LightTime string `json:"lightTime,omitempty"`
	// ModerateTime: Optional. Time spent in moderate heart rate zone.
	ModerateTime string `json:"moderateTime,omitempty"`
	// PeakTime: Optional. Time spent in peak heart rate zone.
	PeakTime string `json:"peakTime,omitempty"`
	// VigorousTime: Optional. Time spent in vigorous heart rate zone.
	VigorousTime string `json:"vigorousTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "LightTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "LightTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeInHeartRateZones) MarshalJSON() ([]byte, error) {
	type NoMethod TimeInHeartRateZones
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeOfDay: Represents a time of day. The date and time zone are either not
// significant or are specified elsewhere. An API may choose to allow leap
// seconds. Related types are google.type.Date and `google.protobuf.Timestamp`.
type TimeOfDay struct {
	// Hours: Hours of a day in 24 hour format. Must be greater than or equal to 0
	// and typically must be less than or equal to 23. An API may choose to allow
	// the value "24:00:00" for scenarios like business closing time.
	Hours int64 `json:"hours,omitempty"`
	// Minutes: Minutes of an hour. Must be greater than or equal to 0 and less
	// than or equal to 59.
	Minutes int64 `json:"minutes,omitempty"`
	// Nanos: Fractions of seconds, in nanoseconds. Must be greater than or equal
	// to 0 and less than or equal to 999,999,999.
	Nanos int64 `json:"nanos,omitempty"`
	// Seconds: Seconds of a minute. Must be greater than or equal to 0 and
	// typically must be less than or equal to 59. An API may allow the value 60 if
	// it allows leap-seconds.
	Seconds int64 `json:"seconds,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Hours") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Hours") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeOfDay) MarshalJSON() ([]byte, error) {
	type NoMethod TimeOfDay
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TimeZone: Represents a time zone from the IANA Time Zone Database
// (https://www.iana.org/time-zones).
type TimeZone struct {
	// Id: IANA Time Zone Database time zone. For example "America/New_York".
	Id string `json:"id,omitempty"`
	// Version: Optional. IANA Time Zone Database version number. For example
	// "2019a".
	Version string `json:"version,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Id") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Id") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TimeZone) MarshalJSON() ([]byte, error) {
	type NoMethod TimeZone
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TotalCaloriesRollupValue: Represents the result of the rollup of the user's
// total calories. Note: Queries for the `total-calories` data type must
// include a time interval filter (such as `total_calories.interval.start_time`
// or `total_calories.interval.civil_start_time`). The maximum range is 14
// days. Example filter query: `total_calories.interval.start_time >=
// "2026-04-20T00:00:00Z" AND total_calories.interval.start_time <
// "2026-04-21T00:00:00Z"
type TotalCaloriesRollupValue struct {
	// KcalSum: Sum of the total calories in kilocalories.
	KcalSum float64 `json:"kcalSum,omitempty"`
	// ForceSendFields is a list of field names (e.g. "KcalSum") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "KcalSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TotalCaloriesRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod TotalCaloriesRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *TotalCaloriesRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod TotalCaloriesRollupValue
	var s1 struct {
		KcalSum gensupport.JSONFloat64 `json:"kcalSum"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.KcalSum = float64(s1.KcalSum)
	return nil
}

// VO2Max: VO2 max measurement.
type VO2Max struct {
	// MeasurementMethod: Optional. The method used to measure the VO2 max value.
	//
	// Possible values:
	//   "MEASUREMENT_METHOD_UNSPECIFIED" - Unspecified measurement method.
	//   "FITBIT_RUN" - Fitbit specific, measures VO2 max rate during a run.
	//   "GOOGLE_DEMOGRAPHIC" - Google specific, measures VO2 max rate for a user
	// based on their demographic data.
	//   "COOPER_TEST" - Run as far as possible for 12 minutes. Distance correlated
	// with age and gender translates to a VO2 max value.
	//   "HEART_RATE_RATIO" - Maximum heart rate divided by the resting heart rate,
	// with a multiplier applied. Does not require any exercise.
	//   "METABOLIC_CART" - Measured by a medical device called metabolic cart.
	//   "MULTISTAGE_FITNESS_TEST" - Continuous 20m back-and-forth runs with
	// increasing difficulty, until exhaustion.
	//   "ROCKPORT_FITNESS_TEST" - Measured using walking exercise.
	//   "MAX_EXERCISE" - Healthkit specific, measures VO2 max rate by monitoring
	// exercise to the user’s physical limit. Similar to COOPER_TEST or
	// MULTISTAGE_FITNESS_TEST.
	//   "PREDICTION_SUB_MAX_EXERCISE" - Healthkit specific, estimates VO2 max rate
	// based on low-intensity exercise. Similar to ROCKPORT_FITNESS_TEST.
	//   "PREDICTION_NON_EXERCISE" - Healthkit specific, estimates VO2 max rate
	// without any exercise. Similar to HEART_RATE_RATIO.
	//   "OTHER" - Use when the method is not covered in this enum.
	MeasurementMethod string `json:"measurementMethod,omitempty"`
	// SampleTime: Required. The time at which VO2 max was measured.
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// Vo2Max: Required. VO2 max value measured as in ml consumed oxygen / kg of
	// body weight / min.
	Vo2Max float64 `json:"vo2Max,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MeasurementMethod") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MeasurementMethod") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VO2Max) MarshalJSON() ([]byte, error) {
	type NoMethod VO2Max
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *VO2Max) UnmarshalJSON(data []byte) error {
	type NoMethod VO2Max
	var s1 struct {
		Vo2Max gensupport.JSONFloat64 `json:"vo2Max"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Vo2Max = float64(s1.Vo2Max)
	return nil
}

// VolumeQuantity: Represents the volume quantity.
type VolumeQuantity struct {
	// Milliliters: Required. Value representing the volume in milliliters.
	Milliliters float64 `json:"milliliters,omitempty"`
	// UserProvidedUnit: Optional. Value representing the user provided unit, used
	// only for user-facing input and display purposes. In the API format, all
	// volume quantities are converted to milliliters.
	//
	// Possible values:
	//   "VOLUME_UNIT_UNSPECIFIED" - Unspecified volume unit.
	//   "CUP_IMPERIAL" - Cup (imperial)
	//   "CUP_US" - Cup (US)
	//   "FLUID_OUNCE_IMPERIAL" - Fluid ounce (imperial)
	//   "FLUID_OUNCE_US" - Fluid ounce (US)
	//   "LITER" - Liter
	//   "MILLILITER" - Milliliter
	//   "PINT_IMPERIAL" - Pint (imperial)
	//   "PINT_US" - Pint (US)
	UserProvidedUnit string `json:"userProvidedUnit,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Milliliters") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Milliliters") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VolumeQuantity) MarshalJSON() ([]byte, error) {
	type NoMethod VolumeQuantity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *VolumeQuantity) UnmarshalJSON(data []byte) error {
	type NoMethod VolumeQuantity
	var s1 struct {
		Milliliters gensupport.JSONFloat64 `json:"milliliters"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Milliliters = float64(s1.Milliliters)
	return nil
}

// VolumeQuantityRollup: Rollup for volume quantity.
type VolumeQuantityRollup struct {
	// MillilitersSum: Required. The sum of volume in milliliters.
	MillilitersSum float64 `json:"millilitersSum,omitempty"`
	// UserProvidedUnitLast: Optional. The user provided unit on the last element.
	//
	// Possible values:
	//   "VOLUME_UNIT_UNSPECIFIED" - Unspecified volume unit.
	//   "CUP_IMPERIAL" - Cup (imperial)
	//   "CUP_US" - Cup (US)
	//   "FLUID_OUNCE_IMPERIAL" - Fluid ounce (imperial)
	//   "FLUID_OUNCE_US" - Fluid ounce (US)
	//   "LITER" - Liter
	//   "MILLILITER" - Milliliter
	//   "PINT_IMPERIAL" - Pint (imperial)
	//   "PINT_US" - Pint (US)
	UserProvidedUnitLast string `json:"userProvidedUnitLast,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MillilitersSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MillilitersSum") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VolumeQuantityRollup) MarshalJSON() ([]byte, error) {
	type NoMethod VolumeQuantityRollup
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *VolumeQuantityRollup) UnmarshalJSON(data []byte) error {
	type NoMethod VolumeQuantityRollup
	var s1 struct {
		MillilitersSum gensupport.JSONFloat64 `json:"millilitersSum"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.MillilitersSum = float64(s1.MillilitersSum)
	return nil
}

// Weight: Body weight measurement.
type Weight struct {
	// Notes: Optional. Standard free-form notes captured at manual logging.
	Notes string `json:"notes,omitempty"`
	// SampleTime: Required. The time at which the weight was measured
	SampleTime *ObservationSampleTime `json:"sampleTime,omitempty"`
	// WeightGrams: Required. Weight of a user in grams.
	WeightGrams float64 `json:"weightGrams,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Notes") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Notes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Weight) MarshalJSON() ([]byte, error) {
	type NoMethod Weight
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *Weight) UnmarshalJSON(data []byte) error {
	type NoMethod Weight
	var s1 struct {
		WeightGrams gensupport.JSONFloat64 `json:"weightGrams"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.WeightGrams = float64(s1.WeightGrams)
	return nil
}

// WeightQuantity: Represents the weight quantity.
type WeightQuantity struct {
	// Grams: Required. The weight value in grams.
	Grams float64 `json:"grams,omitempty"`
	// UserProvidedUnit: Optional. Value representing the user provided unit.
	//
	// Possible values:
	//   "WEIGHT_UNIT_UNSPECIFIED" - Unspecified weight unit.
	//   "GRAM" - Value representing gram.
	//   "KILOGRAM" - Value representing kilogram.
	//   "OUNCE" - Value representing ounce.
	//   "POUND" - Value representing pound.
	//   "STONE" - Value representing stone.
	//   "MILLIGRAM" - Value representing milligram.
	//   "MICROGRAM" - Value representing microgram.
	//   "NANOGRAM" - Value representing nanogram.
	UserProvidedUnit string `json:"userProvidedUnit,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Grams") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Grams") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s WeightQuantity) MarshalJSON() ([]byte, error) {
	type NoMethod WeightQuantity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *WeightQuantity) UnmarshalJSON(data []byte) error {
	type NoMethod WeightQuantity
	var s1 struct {
		Grams gensupport.JSONFloat64 `json:"grams"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Grams = float64(s1.Grams)
	return nil
}

// WeightQuantityRollup: Rollup for the weight.
type WeightQuantityRollup struct {
	// GramsSum: Required. The sum of the weight in grams.
	GramsSum float64 `json:"gramsSum,omitempty"`
	// UserProvidedUnitLast: Optional. The user provided unit on the last element.
	//
	// Possible values:
	//   "WEIGHT_UNIT_UNSPECIFIED" - Unspecified weight unit.
	//   "GRAM" - Value representing gram.
	//   "KILOGRAM" - Value representing kilogram.
	//   "OUNCE" - Value representing ounce.
	//   "POUND" - Value representing pound.
	//   "STONE" - Value representing stone.
	//   "MILLIGRAM" - Value representing milligram.
	//   "MICROGRAM" - Value representing microgram.
	//   "NANOGRAM" - Value representing nanogram.
	UserProvidedUnitLast string `json:"userProvidedUnitLast,omitempty"`
	// ForceSendFields is a list of field names (e.g. "GramsSum") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GramsSum") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s WeightQuantityRollup) MarshalJSON() ([]byte, error) {
	type NoMethod WeightQuantityRollup
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *WeightQuantityRollup) UnmarshalJSON(data []byte) error {
	type NoMethod WeightQuantityRollup
	var s1 struct {
		GramsSum gensupport.JSONFloat64 `json:"gramsSum"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.GramsSum = float64(s1.GramsSum)
	return nil
}

// WeightRollupValue: Represents the result of the rollup of the weight data
// type.
type WeightRollupValue struct {
	// WeightGramsAvg: Average weight in grams.
	WeightGramsAvg float64 `json:"weightGramsAvg,omitempty"`
	// ForceSendFields is a list of field names (e.g. "WeightGramsAvg") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "WeightGramsAvg") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s WeightRollupValue) MarshalJSON() ([]byte, error) {
	type NoMethod WeightRollupValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *WeightRollupValue) UnmarshalJSON(data []byte) error {
	type NoMethod WeightRollupValue
	var s1 struct {
		WeightGramsAvg gensupport.JSONFloat64 `json:"weightGramsAvg"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.WeightGramsAvg = float64(s1.WeightGramsAvg)
	return nil
}

type ProjectsSubscribersCreateCall struct {
	s                       *Service
	parent                  string
	createsubscriberpayload *CreateSubscriberPayload
	urlParams_              gensupport.URLParams
	ctx_                    context.Context
	header_                 http.Header
}

// Create: Registers a new subscriber endpoint to receive notifications. A
// subscriber represents an application or service that wishes to receive data
// change notifications for users who have granted consent. **Endpoint
// Verification:** For a subscriber to be successfully created, the provided
// `endpoint_uri` must be a valid HTTPS endpoint and must pass an automated
// verification check. The backend will send two HTTP POST requests to the
// `endpoint_uri`: 1. **Verification with Authorization:** * **Headers:**
// Includes `Content-Type: application/json` and `Authorization` (with the
// exact value from `CreateSubscriberPayload.endpoint_authorization.secret`). *
// **Body:** `{"type": "verification"}` * **Expected Response:** HTTP `201
// Created`. 2. **Verification without Authorization:** * **Headers:** Includes
// `Content-Type: application/json`. The `Authorization` header is OMITTED. *
// **Body:** `{"type": "verification"}` * **Expected Response:** HTTP `401
// Unauthorized` or `403 Forbidden`. Both tests must pass for the subscriber
// creation to succeed. If verification fails, the operation will not be
// completed and an error will be returned. This process ensures the endpoint
// is reachable and correctly validates the `Authorization` header.
//
//   - parent: The parent resource where this subscriber will be created. Format:
//     projects/{project_number} Example: projects/1234567890.
func (r *ProjectsSubscribersService) Create(parent string, createsubscriberpayload *CreateSubscriberPayload) *ProjectsSubscribersCreateCall {
	c := &ProjectsSubscribersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.createsubscriberpayload = createsubscriberpayload
	return c
}

// SubscriberId sets the optional parameter "subscriberId": The ID to use for
// the subscriber, which will become the final component of the subscriber's
// resource name. This value should be 4-36 characters, and valid characters
// are /a-z ([a-z0-9-]{2,34}[a-z0-9])/.
func (c *ProjectsSubscribersCreateCall) SubscriberId(subscriberId string) *ProjectsSubscribersCreateCall {
	c.urlParams_.Set("subscriberId", subscriberId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersCreateCall) Fields(s ...googleapi.Field) *ProjectsSubscribersCreateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersCreateCall) Context(ctx context.Context) *ProjectsSubscribersCreateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersCreateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersCreateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.createsubscriberpayload)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/subscribers")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.create", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.create" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsSubscribersCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.create", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsSubscribersDeleteCall struct {
	s          *Service
	name       string
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a subscriber registration. This will stop all notifications
// to the subscriber's endpoint.
//
//   - name: The name of the subscriber to delete. Format:
//     projects/{project}/subscribers/{subscriber} Example:
//     projects/my-project/subscribers/my-subscriber-123 The {subscriber} ID is
//     user-settable (4-36 characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/)
//     or system-generated if not provided during creation.
func (r *ProjectsSubscribersService) Delete(name string) *ProjectsSubscribersDeleteCall {
	c := &ProjectsSubscribersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Force sets the optional parameter "force": If set to true, any child
// resources (e.g., subscriptions) will also be deleted. If false (default) and
// child resources exist, the request will fail.
func (c *ProjectsSubscribersDeleteCall) Force(force bool) *ProjectsSubscribersDeleteCall {
	c.urlParams_.Set("force", fmt.Sprint(force))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersDeleteCall) Fields(s ...googleapi.Field) *ProjectsSubscribersDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersDeleteCall) Context(ctx context.Context) *ProjectsSubscribersDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.delete" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsSubscribersDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.delete", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsSubscribersListCall struct {
	s            *Service
	parent       string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Lists all subscribers registered within the owned Google Cloud
// Project.
//
//   - parent: The parent, which owns this collection of subscribers. Format:
//     projects/{project}.
func (r *ProjectsSubscribersService) List(parent string) *ProjectsSubscribersListCall {
	c := &ProjectsSubscribersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of
// subscribers to return. The service may return fewer than this value. If
// unspecified, at most 50 subscribers will be returned. The maximum value is
// 1000; values above 1000 will be coerced to 1000.
func (c *ProjectsSubscribersListCall) PageSize(pageSize int64) *ProjectsSubscribersListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": A page token, received
// from a previous `ListSubscribers` call. Provide this to retrieve the
// subsequent page. When paginating, all other parameters provided to
// `ListSubscribers` must match the call that provided the page token.
func (c *ProjectsSubscribersListCall) PageToken(pageToken string) *ProjectsSubscribersListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersListCall) Fields(s ...googleapi.Field) *ProjectsSubscribersListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ProjectsSubscribersListCall) IfNoneMatch(entityTag string) *ProjectsSubscribersListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersListCall) Context(ctx context.Context) *ProjectsSubscribersListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/subscribers")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListSubscribersResponse.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 (c *ProjectsSubscribersListCall) Do(opts ...googleapi.CallOption) (*ListSubscribersResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListSubscribersResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsSubscribersListCall) Pages(ctx context.Context, f func(*ListSubscribersResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type ProjectsSubscribersPatchCall struct {
	s          *Service
	name       string
	subscriber *Subscriber
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Patch: Updates the configuration of an existing subscriber, such as the
// endpoint URI or the data types it's interested in. **Endpoint
// Verification:** If the `endpoint_uri` or `endpoint_authorization` field is
// included in the `update_mask`, the backend will re-verify the endpoint. The
// verification process is the same as described in `CreateSubscriber`: 1.
// **Verification with Authorization:** POST to the new or existing
// `endpoint_uri` with the new or existing `Authorization` secret. Expects HTTP
// `201 Created`. 2. **Verification without Authorization:** POST to the
// `endpoint_uri` without the `Authorization` header. Expects HTTP `401
// Unauthorized` or `403 Forbidden`. Both tests must pass using the potentially
// updated values for the subscriber update to succeed. If verification fails,
// the update will not be applied, and an error will be returned.
//
//   - name: Identifier. The resource name of the Subscriber. Format:
//     projects/{project}/subscribers/{subscriber} The {project} ID is a Google
//     Cloud Project ID or Project Number. The {subscriber} ID is user-settable
//     (4-36 characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) if provided
//     during creation, or system-generated otherwise (e.g., a UUID). Example
//     (User-settable subscriber ID): projects/my-project/subscribers/my-sub-123
//     Example (System-generated subscriber ID):
//     projects/my-project/subscribers/a1b2c3d4-e5f6-7890-1234-567890abcdef.
func (r *ProjectsSubscribersService) Patch(name string, subscriber *Subscriber) *ProjectsSubscribersPatchCall {
	c := &ProjectsSubscribersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.subscriber = subscriber
	return c
}

// UpdateMask sets the optional parameter "updateMask": A field mask that
// specifies which fields of the Subscriber message are to be updated. This
// allows for partial updates. Supported fields: - endpoint_uri -
// subscriber_configs - endpoint_authorization
func (c *ProjectsSubscribersPatchCall) UpdateMask(updateMask string) *ProjectsSubscribersPatchCall {
	c.urlParams_.Set("updateMask", updateMask)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersPatchCall) Fields(s ...googleapi.Field) *ProjectsSubscribersPatchCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersPatchCall) Context(ctx context.Context) *ProjectsSubscribersPatchCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersPatchCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersPatchCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.subscriber)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.patch", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.patch" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsSubscribersPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.patch", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsSubscribersSubscriptionsCreateCall struct {
	s                         *Service
	parent                    string
	createsubscriptionpayload *CreateSubscriptionPayload
	urlParams_                gensupport.URLParams
	ctx_                      context.Context
	header_                   http.Header
}

// Create: Creates a subscription for a specific user to a specific subscriber.
// This method requires the subscriber to have a `SubscriptionCreatePolicy` set
// to `MANUAL` for the given data types.
//
//   - parent: The parent subscriber. Format:
//     projects/{project}/subscribers/{subscriber} The {subscriber} ID is
//     user-settable (4-36 characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/)
//     if provided during creation, or system-generated otherwise.
func (r *ProjectsSubscribersSubscriptionsService) Create(parent string, createsubscriptionpayload *CreateSubscriptionPayload) *ProjectsSubscribersSubscriptionsCreateCall {
	c := &ProjectsSubscribersSubscriptionsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.createsubscriptionpayload = createsubscriptionpayload
	return c
}

// SubscriptionId sets the optional parameter "subscriptionId": The
// {subscription_id} is user-settable (4-36 chars, matching /a-z
// ([a-z0-9-]{2,34}[a-z0-9])/) or system-generated otherwise. If provided, the
// ID must be unique within the parent subscriber.
func (c *ProjectsSubscribersSubscriptionsCreateCall) SubscriptionId(subscriptionId string) *ProjectsSubscribersSubscriptionsCreateCall {
	c.urlParams_.Set("subscriptionId", subscriptionId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersSubscriptionsCreateCall) Fields(s ...googleapi.Field) *ProjectsSubscribersSubscriptionsCreateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersSubscriptionsCreateCall) Context(ctx context.Context) *ProjectsSubscribersSubscriptionsCreateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersSubscriptionsCreateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersSubscriptionsCreateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.createsubscriptionpayload)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/subscriptions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.create", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.subscriptions.create" call.
// Any non-2xx status code is an error. Response headers are in either
// *Subscription.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 (c *ProjectsSubscribersSubscriptionsCreateCall) Do(opts ...googleapi.CallOption) (*Subscription, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Subscription{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.create", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsSubscribersSubscriptionsDeleteCall struct {
	s          *Service
	name       string
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a specific user subscription, stopping notifications for
// this user to this subscriber.
//
//   - name: The resource name of the subscription to delete. Format:
//     `projects/{project}/subscribers/{subscriber}/subscriptions/{subscription}`
//     Example:
//     `projects/my-project/subscribers/my-subscriber-123/subscriptions/my-subscri
//     ption-456` The {subscriber} ID is user-settable (4-36 characters, matching
//     /a-z ([a-z0-9-]{2,34}[a-z0-9])/) if provided during creation, or
//     system-generated otherwise. The {subscription} ID is user-settable (4-36
//     characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) or system-generated
//     if not provided during creation.
func (r *ProjectsSubscribersSubscriptionsService) Delete(name string) *ProjectsSubscribersSubscriptionsDeleteCall {
	c := &ProjectsSubscribersSubscriptionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersSubscriptionsDeleteCall) Fields(s ...googleapi.Field) *ProjectsSubscribersSubscriptionsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersSubscriptionsDeleteCall) Context(ctx context.Context) *ProjectsSubscribersSubscriptionsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersSubscriptionsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersSubscriptionsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.subscriptions.delete" call.
// Any non-2xx status code is an error. Response headers are in either
// *Empty.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsSubscribersSubscriptionsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Empty{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.delete", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsSubscribersSubscriptionsListCall struct {
	s            *Service
	parent       string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Lists all active subscriptions for a given subscriber. This can be
// filtered, for example, by user or data type.
//
//   - parent: The parent subscriber. Format:
//     projects/{project}/subscribers/{subscriber} The {subscriber} ID is
//     user-settable (4-36 characters, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/)
//     if provided during creation, or system-generated otherwise.
func (r *ProjectsSubscribersSubscriptionsService) List(parent string) *ProjectsSubscribersSubscriptionsListCall {
	c := &ProjectsSubscribersSubscriptionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// Filter sets the optional parameter "filter": A filter to apply to the list
// of subscriptions. The filter syntax is described in
// https://google.aip.dev/160. The filter can be applied to the following
// fields: - `user` - `data_type` The `user` identifier (e.g., `user1` in
// `users/user1`) refers to the public `health_user_id` Example: user =
// "users/user1" Example: user = "users/user1" OR user = "users/user2" Example:
// user = "users/user1" AND (data_type = "sleep" OR data_type = "weight")
func (c *ProjectsSubscribersSubscriptionsListCall) Filter(filter string) *ProjectsSubscribersSubscriptionsListCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of
// subscriptions to return. The service may return fewer than this value. If
// unspecified, at most 50 subscriptions will be returned. The maximum value is
// 1000; values above 1000 will be coerced to 1000.
func (c *ProjectsSubscribersSubscriptionsListCall) PageSize(pageSize int64) *ProjectsSubscribersSubscriptionsListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": A page token, received
// from a previous `ListSubscriptions` call. Provide this to retrieve the
// subsequent page. When paginating, all other parameters provided to
// `ListSubscriptions` must match the call that provided the page token.
func (c *ProjectsSubscribersSubscriptionsListCall) PageToken(pageToken string) *ProjectsSubscribersSubscriptionsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersSubscriptionsListCall) Fields(s ...googleapi.Field) *ProjectsSubscribersSubscriptionsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ProjectsSubscribersSubscriptionsListCall) IfNoneMatch(entityTag string) *ProjectsSubscribersSubscriptionsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersSubscriptionsListCall) Context(ctx context.Context) *ProjectsSubscribersSubscriptionsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersSubscriptionsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersSubscriptionsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/subscriptions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.subscriptions.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListSubscriptionsResponse.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 (c *ProjectsSubscribersSubscriptionsListCall) Do(opts ...googleapi.CallOption) (*ListSubscriptionsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListSubscriptionsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsSubscribersSubscriptionsListCall) Pages(ctx context.Context, f func(*ListSubscriptionsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type ProjectsSubscribersSubscriptionsPatchCall struct {
	s            *Service
	name         string
	subscription *Subscription
	urlParams_   gensupport.URLParams
	ctx_         context.Context
	header_      http.Header
}

// Patch: Updates the data types for an existing user subscription.
//
//   - name: Identifier. The resource name of the Subscription. Format:
//     `projects/{project}/subscribers/{subscriber}/subscriptions/{subscription}`
//     Example:
//     `projects/my-project/subscribers/my-subscriber-123/subscriptions/my-subscri
//     ption-456` The {project} ID is mandatory (6-30 characters, matching
//     /a-z{6,30}/) The {subscriber} ID is user-settable (4-36 characters,
//     matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) if provided during creation, or
//     system-generated otherwise. The {subscription} ID is user-settable (4-36
//     chars, matching /a-z ([a-z0-9-]{2,34}[a-z0-9])/) or system-generated
//     otherwise.
func (r *ProjectsSubscribersSubscriptionsService) Patch(name string, subscription *Subscription) *ProjectsSubscribersSubscriptionsPatchCall {
	c := &ProjectsSubscribersSubscriptionsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.subscription = subscription
	return c
}

// UpdateMask sets the optional parameter "updateMask": The list of fields to
// update.
func (c *ProjectsSubscribersSubscriptionsPatchCall) UpdateMask(updateMask string) *ProjectsSubscribersSubscriptionsPatchCall {
	c.urlParams_.Set("updateMask", updateMask)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ProjectsSubscribersSubscriptionsPatchCall) Fields(s ...googleapi.Field) *ProjectsSubscribersSubscriptionsPatchCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ProjectsSubscribersSubscriptionsPatchCall) Context(ctx context.Context) *ProjectsSubscribersSubscriptionsPatchCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ProjectsSubscribersSubscriptionsPatchCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ProjectsSubscribersSubscriptionsPatchCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.subscription)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.patch", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.projects.subscribers.subscriptions.patch" call.
// Any non-2xx status code is an error. Response headers are in either
// *Subscription.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 (c *ProjectsSubscribersSubscriptionsPatchCall) Do(opts ...googleapi.CallOption) (*Subscription, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Subscription{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.projects.subscribers.subscriptions.patch", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ShlMGetShlManifestCall struct {
	s              *Service
	externalShlId  string
	manifestparams *ManifestParams
	urlParams_     gensupport.URLParams
	ctx_           context.Context
	header_        http.Header
}

// GetShlManifest: Forward a manifest request for a given SHL
//
//   - externalShlId: External ID mapping to a ShlSharedLinkCapabilityToken
//     object See
//     https://docs.google.com/document/d/1Pch20pxJHRbsaMxp0EYgs3ZU0Gu7QTUznk8LhvbQvfY/edit?tab=t.0#heading=h.17wg41voij6q.
func (r *ShlMService) GetShlManifest(externalShlId string, manifestparams *ManifestParams) *ShlMGetShlManifestCall {
	c := &ShlMGetShlManifestCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.externalShlId = externalShlId
	c.manifestparams = manifestparams
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ShlMGetShlManifestCall) Fields(s ...googleapi.Field) *ShlMGetShlManifestCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ShlMGetShlManifestCall) Context(ctx context.Context) *ShlMGetShlManifestCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ShlMGetShlManifestCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ShlMGetShlManifestCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.manifestparams)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/shl/m/{externalShlId}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"externalShlId": c.externalShlId,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.shl.m.getShlManifest", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.shl.m.getShlManifest" call.
// Any non-2xx status code is an error. Response headers are in either
// *HttpBody.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 (c *ShlMGetShlManifestCall) Do(opts ...googleapi.CallOption) (*HttpBody, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &HttpBody{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.shl.m.getShlManifest", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ShlRGetCall struct {
	s             *Service
	externalShlId string
	resourceToken string
	urlParams_    gensupport.URLParams
	ifNoneMatch_  string
	ctx_          context.Context
	header_       http.Header
}

// Get: Forward a resource request for a given SHL
//
//   - externalShlId: External ID mapping to a ShlSharedLinkCapabilityToken
//     object See
//     https://docs.google.com/document/d/1Pch20pxJHRbsaMxp0EYgs3ZU0Gu7QTUznk8LhvbQvfY/edit?tab=t.0#heading=h.17wg41voij6q.
//   - resourceToken: Encoded, encrypted message containing resource access
//     details.
func (r *ShlRService) Get(externalShlId string, resourceToken string) *ShlRGetCall {
	c := &ShlRGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.externalShlId = externalShlId
	c.resourceToken = resourceToken
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ShlRGetCall) Fields(s ...googleapi.Field) *ShlRGetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ShlRGetCall) IfNoneMatch(entityTag string) *ShlRGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ShlRGetCall) Context(ctx context.Context) *ShlRGetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ShlRGetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ShlRGetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/shl/r/{externalShlId}/{resourceToken}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"externalShlId": c.externalShlId,
		"resourceToken": c.resourceToken,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.shl.r.get", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.shl.r.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *HttpBody.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 (c *ShlRGetCall) Do(opts ...googleapi.CallOption) (*HttpBody, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &HttpBody{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.shl.r.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersGetIdentityCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// GetIdentity: Gets the user's identity. It includes the legacy Fitbit user ID
// and the Google user ID and it can be used by migrating clients to map
// identifiers between the two systems.
//
// - name: The resource name of the Identity. Format: `users/me/identity`.
func (r *UsersService) GetIdentity(name string) *UsersGetIdentityCall {
	c := &UsersGetIdentityCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersGetIdentityCall) Fields(s ...googleapi.Field) *UsersGetIdentityCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersGetIdentityCall) IfNoneMatch(entityTag string) *UsersGetIdentityCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersGetIdentityCall) Context(ctx context.Context) *UsersGetIdentityCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersGetIdentityCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersGetIdentityCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.getIdentity", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.getIdentity" call.
// Any non-2xx status code is an error. Response headers are in either
// *Identity.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 (c *UsersGetIdentityCall) Do(opts ...googleapi.CallOption) (*Identity, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Identity{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.getIdentity", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersGetIrnProfileCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// GetIrnProfile: Returns user's IRN Profile details.
//
//   - name: The resource name of the IRN Profile. Format:
//     `users/{user}/irnProfile` Example: `users/1234567890/irnProfile` or
//     `users/me/irnProfile` The {user} ID is a system-generated Google Health
//     API user ID, a string of 1-63 characters consisting of lowercase and
//     uppercase letters, numbers, and hyphens. The literal `me` can also be used
//     to refer to the authenticated user.
func (r *UsersService) GetIrnProfile(name string) *UsersGetIrnProfileCall {
	c := &UsersGetIrnProfileCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersGetIrnProfileCall) Fields(s ...googleapi.Field) *UsersGetIrnProfileCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersGetIrnProfileCall) IfNoneMatch(entityTag string) *UsersGetIrnProfileCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersGetIrnProfileCall) Context(ctx context.Context) *UsersGetIrnProfileCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersGetIrnProfileCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersGetIrnProfileCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.getIrnProfile", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.getIrnProfile" call.
// Any non-2xx status code is an error. Response headers are in either
// *IrnProfile.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 (c *UsersGetIrnProfileCall) Do(opts ...googleapi.CallOption) (*IrnProfile, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &IrnProfile{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.getIrnProfile", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersGetProfileCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// GetProfile: Returns user Profile details.
//
// - name: The name of the Profile. Format: `users/me/profile`.
func (r *UsersService) GetProfile(name string) *UsersGetProfileCall {
	c := &UsersGetProfileCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersGetProfileCall) Fields(s ...googleapi.Field) *UsersGetProfileCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersGetProfileCall) IfNoneMatch(entityTag string) *UsersGetProfileCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersGetProfileCall) Context(ctx context.Context) *UsersGetProfileCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersGetProfileCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersGetProfileCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.getProfile", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.getProfile" call.
// Any non-2xx status code is an error. Response headers are in either
// *Profile.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 (c *UsersGetProfileCall) Do(opts ...googleapi.CallOption) (*Profile, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Profile{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.getProfile", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersGetSettingsCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// GetSettings: Returns user settings details.
//
// - name: The name of the Settings. Format: `users/me/settings`.
func (r *UsersService) GetSettings(name string) *UsersGetSettingsCall {
	c := &UsersGetSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersGetSettingsCall) Fields(s ...googleapi.Field) *UsersGetSettingsCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersGetSettingsCall) IfNoneMatch(entityTag string) *UsersGetSettingsCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersGetSettingsCall) Context(ctx context.Context) *UsersGetSettingsCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersGetSettingsCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersGetSettingsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.getSettings", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.getSettings" call.
// Any non-2xx status code is an error. Response headers are in either
// *Settings.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 (c *UsersGetSettingsCall) Do(opts ...googleapi.CallOption) (*Settings, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Settings{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.getSettings", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersUpdateProfileCall struct {
	s          *Service
	name       string
	profile    *Profile
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// UpdateProfile: Updates the user's profile details.
//
//   - name: Identifier. The resource name of this Profile resource. Format:
//     `users/{user}/profile` Example: `users/1234567890/profile` or
//     `users/me/profile` The {user} ID is a system-generated Google Health API
//     user ID, a string of 1-63 characters consisting of lowercase and uppercase
//     letters, numbers, and hyphens. The literal `me` can also be used to refer
//     to the authenticated user.
func (r *UsersService) UpdateProfile(name string, profile *Profile) *UsersUpdateProfileCall {
	c := &UsersUpdateProfileCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.profile = profile
	return c
}

// UpdateMask sets the optional parameter "updateMask": The list of fields to
// be updated.
func (c *UsersUpdateProfileCall) UpdateMask(updateMask string) *UsersUpdateProfileCall {
	c.urlParams_.Set("updateMask", updateMask)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersUpdateProfileCall) Fields(s ...googleapi.Field) *UsersUpdateProfileCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersUpdateProfileCall) Context(ctx context.Context) *UsersUpdateProfileCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersUpdateProfileCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersUpdateProfileCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.profile)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.updateProfile", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.updateProfile" call.
// Any non-2xx status code is an error. Response headers are in either
// *Profile.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 (c *UsersUpdateProfileCall) Do(opts ...googleapi.CallOption) (*Profile, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Profile{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.updateProfile", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersUpdateSettingsCall struct {
	s          *Service
	name       string
	settings   *Settings
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// UpdateSettings: Updates the user's settings details.
//
//   - name: Identifier. The resource name of this Settings resource. Format:
//     `users/{user}/settings` Example: `users/1234567890/settings` or
//     `users/me/settings` The {user} ID is a system-generated Google Health API
//     user ID, a string of 1-63 characters consisting of lowercase and uppercase
//     letters, numbers, and hyphens. The literal `me` can also be used to refer
//     to the authenticated user.
func (r *UsersService) UpdateSettings(name string, settings *Settings) *UsersUpdateSettingsCall {
	c := &UsersUpdateSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.settings = settings
	return c
}

// UpdateMask sets the optional parameter "updateMask": The list of fields to
// be updated.
func (c *UsersUpdateSettingsCall) UpdateMask(updateMask string) *UsersUpdateSettingsCall {
	c.urlParams_.Set("updateMask", updateMask)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersUpdateSettingsCall) Fields(s ...googleapi.Field) *UsersUpdateSettingsCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersUpdateSettingsCall) Context(ctx context.Context) *UsersUpdateSettingsCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersUpdateSettingsCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersUpdateSettingsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.settings)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.updateSettings", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.updateSettings" call.
// Any non-2xx status code is an error. Response headers are in either
// *Settings.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 (c *UsersUpdateSettingsCall) Do(opts ...googleapi.CallOption) (*Settings, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Settings{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.updateSettings", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsBatchDeleteCall struct {
	s                            *Service
	parent                       string
	batchdeletedatapointsrequest *BatchDeleteDataPointsRequest
	urlParams_                   gensupport.URLParams
	ctx_                         context.Context
	header_                      http.Header
}

// BatchDelete: Delete a batch of identifyable data points.
//
//   - parent: Optional. Parent (data type) for the Data Point collection Format:
//     `users/me/dataTypes/{data_type}`, e.g.: - `users/me/dataTypes/steps` -
//     `users/me/dataTypes/-` For a list of the supported data types see the
//     DataPoint data union field. Deleting data points across multiple data type
//     collections is supported following https://aip.dev/159. If this is set,
//     the parent of all of the data points specified in `names` must match this
//     field.
func (r *UsersDataTypesDataPointsService) BatchDelete(parent string, batchdeletedatapointsrequest *BatchDeleteDataPointsRequest) *UsersDataTypesDataPointsBatchDeleteCall {
	c := &UsersDataTypesDataPointsBatchDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.batchdeletedatapointsrequest = batchdeletedatapointsrequest
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsBatchDeleteCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsBatchDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsBatchDeleteCall) Context(ctx context.Context) *UsersDataTypesDataPointsBatchDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsBatchDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsBatchDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.batchdeletedatapointsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints:batchDelete")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.batchDelete", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.batchDelete" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *UsersDataTypesDataPointsBatchDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.batchDelete", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsCreateCall struct {
	s          *Service
	parent     string
	datapoint  *DataPoint
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Create: Creates a single identifiable data point.
//
//   - parent: The parent resource name where the data point will be created.
//     Format: `users/{user}/dataTypes/{data_type}`.
func (r *UsersDataTypesDataPointsService) Create(parent string, datapoint *DataPoint) *UsersDataTypesDataPointsCreateCall {
	c := &UsersDataTypesDataPointsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.datapoint = datapoint
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsCreateCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsCreateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsCreateCall) Context(ctx context.Context) *UsersDataTypesDataPointsCreateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsCreateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsCreateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.datapoint)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.create", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.create" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *UsersDataTypesDataPointsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.create", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsDailyRollUpCall struct {
	s                            *Service
	parent                       string
	dailyrollupdatapointsrequest *DailyRollUpDataPointsRequest
	urlParams_                   gensupport.URLParams
	ctx_                         context.Context
	header_                      http.Header
}

// DailyRollUp: Roll up data points over civil time intervals for supported
// data types.
//
//   - parent: Parent data type of the Data Point collection. Format:
//     `users/{user}/dataTypes/{data_type}`, e.g.: - `users/me/dataTypes/steps` -
//     `users/me/dataTypes/distance` For a list of the supported data types see
//     the DailyRollupDataPoint value union field.
func (r *UsersDataTypesDataPointsService) DailyRollUp(parent string, dailyrollupdatapointsrequest *DailyRollUpDataPointsRequest) *UsersDataTypesDataPointsDailyRollUpCall {
	c := &UsersDataTypesDataPointsDailyRollUpCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.dailyrollupdatapointsrequest = dailyrollupdatapointsrequest
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsDailyRollUpCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsDailyRollUpCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsDailyRollUpCall) Context(ctx context.Context) *UsersDataTypesDataPointsDailyRollUpCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsDailyRollUpCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsDailyRollUpCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.dailyrollupdatapointsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints:dailyRollUp")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.dailyRollUp", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.dailyRollUp" call.
// Any non-2xx status code is an error. Response headers are in either
// *DailyRollUpDataPointsResponse.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 (c *UsersDataTypesDataPointsDailyRollUpCall) Do(opts ...googleapi.CallOption) (*DailyRollUpDataPointsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &DailyRollUpDataPointsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.dailyRollUp", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsExportExerciseTcxCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// ExportExerciseTcx: Exports exercise data in TCX format. **IMPORTANT:** HTTP
// clients must append `?alt=media` to the request URL to download the raw TCX
// file. Example:
// `https://health.googleapis.com/v4/users/me/dataTypes/exercise/dataPoints/EXER
// CISE_ID:exportExerciseTcx?alt=media` Without `alt=media`, the server returns
// a JSON response (`ExportExerciseTcxResponse`) which is intended primarily
// for gRPC clients. **Note:** While the Authorization section below states
// that any one of the listed scopes is accepted, this specific method requires
// the user to provide both one of the `activity_and_fitness` scopes (`normal`
// or `readonly`) AND one of the `location` scopes (`normal` or `readonly`) in
// their access token to succeed.
//
//   - name: The resource name of the exercise data point to export. Format:
//     `users/{user}/dataTypes/exercise/dataPoints/{data_point}` Example:
//     `users/me/dataTypes/exercise/dataPoints/2026443605080188808` The `{user}`
//     is the alias "me" currently. Future versions may support user IDs. The
//     `{data_point}` ID maps to the exercise ID, which is a long integer.
func (r *UsersDataTypesDataPointsService) ExportExerciseTcx(name string) *UsersDataTypesDataPointsExportExerciseTcxCall {
	c := &UsersDataTypesDataPointsExportExerciseTcxCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// PartialData sets the optional parameter "partialData": Indicates whether to
// include the TCX data points when the GPS data is not available. If not
// specified, defaults to `false` and partial data will not be included.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) PartialData(partialData bool) *UsersDataTypesDataPointsExportExerciseTcxCall {
	c.urlParams_.Set("partialData", fmt.Sprint(partialData))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsExportExerciseTcxCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) IfNoneMatch(entityTag string) *UsersDataTypesDataPointsExportExerciseTcxCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do and Download methods.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) Context(ctx context.Context) *UsersDataTypesDataPointsExportExerciseTcxCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsExportExerciseTcxCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}:exportExerciseTcx")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.exportExerciseTcx", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Download fetches the API endpoint's "media" value, instead of the normal
// API response value. If the returned error is nil, the Response is guaranteed to
// have a 2xx status code. Callers must close the Response.Body as usual.
func (c *UsersDataTypesDataPointsExportExerciseTcxCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("media")
	if err != nil {
		return nil, err
	}
	if err := googleapi.CheckResponse(res); err != nil {
		res.Body.Close()
		return nil, gensupport.WrapError(err)
	}
	return res, nil
}

// Do executes the "health.users.dataTypes.dataPoints.exportExerciseTcx" call.
// Any non-2xx status code is an error. Response headers are in either
// *ExportExerciseTcxResponse.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 (c *UsersDataTypesDataPointsExportExerciseTcxCall) Do(opts ...googleapi.CallOption) (*ExportExerciseTcxResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ExportExerciseTcxResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.exportExerciseTcx", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsGetCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Get: Get a single identifyable data point.
//
//   - name: The name of the data point to retrieve. Format:
//     `users/{user}/dataTypes/{data_type}/dataPoints/{data_point}` See
//     DataPoint.name for examples and possible values.
func (r *UsersDataTypesDataPointsService) Get(name string) *UsersDataTypesDataPointsGetCall {
	c := &UsersDataTypesDataPointsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsGetCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsGetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersDataTypesDataPointsGetCall) IfNoneMatch(entityTag string) *UsersDataTypesDataPointsGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsGetCall) Context(ctx context.Context) *UsersDataTypesDataPointsGetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsGetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsGetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.get", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *DataPoint.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 (c *UsersDataTypesDataPointsGetCall) Do(opts ...googleapi.CallOption) (*DataPoint, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &DataPoint{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsListCall struct {
	s            *Service
	parent       string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Query user health and fitness data points.
//
//   - parent: Parent data type of the Data Point collection. Format:
//     `users/me/dataTypes/{data_type}`, e.g.: - `users/me/dataTypes/steps` -
//     `users/me/dataTypes/weight` For a list of the supported data types see the
//     DataPoint data union field.
func (r *UsersDataTypesDataPointsService) List(parent string) *UsersDataTypesDataPointsListCall {
	c := &UsersDataTypesDataPointsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// Filter sets the optional parameter "filter": Filter expression following
// https://google.aip.dev/160. A time range (either physical or civil) can be
// specified. The supported filter fields are: - Interval start time: -
// Pattern: `{interval_data_type}.interval.start_time` - Supported comparison
// operators: `>=`, `<` - Timestamp literal expected in RFC-3339 format -
// Supported logical operators: `AND` - Example: - `steps.interval.start_time
// >= "2023-11-24T00:00:00Z" AND steps.interval.start_time <
// "2023-11-25T00:00:00Z" - `distance.interval.start_time >=
// "2024-08-14T12:34:56Z" - Interval civil start time: - Pattern:
// `{interval_data_type}.interval.civil_start_time` - Supported comparison
// operators: `>=`, `<` - Date with optional time literal expected in ISO 8601
// `YYYY-MM-DD[THH:mm:ss]` format - Supported logical operators: `AND` -
// Example: - `steps.interval.civil_start_time >= "2023-11-24" AND
// steps.interval.civil_start_time < "2023-11-25" -
// `distance.interval.civil_start_time >= "2024-08-14T12:34:56" - Sample
// observation physical time: - Pattern:
// `{sample_data_type}.sample_time.physical_time` - Supported comparison
// operators: `>=`, `<` - Timestamp literal expected in RFC-3339 format -
// Supported logical operators: `AND` - Example: -
// `weight.sample_time.physical_time >= "2023-11-24T00:00:00Z" AND
// weight.sample_time.physical_time < "2023-11-25T00:00:00Z" -
// `weight.sample_time.physical_time >= "2024-08-14T12:34:56Z" - Sample
// observation civil time: - Pattern:
// `{sample_data_type}.sample_time.civil_time` - Supported comparison
// operators: `>=`, `<` - Date with optional time literal expected in ISO 8601
// `YYYY-MM-DD[THH:mm:ss]` format - Supported logical operators: `AND` -
// Example: - `weight.sample_time.civil_time >= "2023-11-24" AND
// weight.sample_time.civil_time < "2023-11-25" -
// `weight.sample_time.civil_time >= "2024-08-14T12:34:56" - Daily summary
// date: - Pattern: `{daily_summary_data_type}.date` - Supported comparison
// operators: `>=`, `<` - Date literal expected in ISO 8601 `YYYY-MM-DD` format
// - Supported logical operators: `AND` - Example: -
// `daily_heart_rate_variability.date < "2024-08-15" - Session civil start
// time (**Excluding Sleep and ECG**): - Pattern:
// `{session_data_type}.interval.civil_start_time` - Supported comparison
// operators: `>=`, `<` - Date with optional time literal expected in ISO 8601
// `YYYY-MM-DD[THH:mm:ss]` format - Supported logical operators: `AND` -
// Example: - `exercise.interval.civil_start_time >= "2023-11-24" AND
// exercise.interval.civil_start_time < "2023-11-25" -
// `exercise.interval.civil_start_time >= "2024-08-14T12:34:56" - Session
// start time (**ECG specific**): - Pattern:
// `electrocardiogram.interval.start_time` - Supported comparison operators:
// `>=` - Timestamp literal expected in RFC-3339 format - Example: -
// `electrocardiogram.interval.start_time >= "2024-08-14T12:34:56Z" - Note:
// Only filtering by start time is supported for ECG. Filtering by end time
// (e.g., `electrocardiogram.interval.end_time`) is not supported. - Session
// end time (**Sleep specific**): - Pattern: `sleep.interval.end_time` -
// Supported comparison operators: `>=`, `<` - Timestamp literal expected in
// RFC-3339 format - Supported logical operators: `AND`, `OR` - Example: -
// `sleep.interval.end_time >= "2023-11-24T00:00:00Z" AND
// sleep.interval.end_time < "2023-11-25T00:00:00Z" - Session civil end time
// (**Sleep specific**): - Pattern: `sleep.interval.civil_end_time` - Supported
// comparison operators: `>=`, `<` - Date with optional time literal expected
// in ISO 8601 `YYYY-MM-DD[THH:mm:ss]` format - Supported logical operators:
// `AND`, `OR` - Example: - `sleep.interval.civil_end_time >= "2023-11-24" AND
// sleep.interval.civil_end_time < "2023-11-25" Data points in the response
// will be ordered by the interval start time in descending order.
func (c *UsersDataTypesDataPointsListCall) Filter(filter string) *UsersDataTypesDataPointsListCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of data
// points to return. If unspecified, at most 1440 data points will be returned.
// The maximum page size is 10000; values above that will be truncated
// accordingly. For `exercise` and `sleep` the default page size is 25. The
// maximum page size for `exercise` and `sleep` is 25.
func (c *UsersDataTypesDataPointsListCall) PageSize(pageSize int64) *UsersDataTypesDataPointsListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": The `next_page_token`
// from a previous request, if any.
func (c *UsersDataTypesDataPointsListCall) PageToken(pageToken string) *UsersDataTypesDataPointsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsListCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersDataTypesDataPointsListCall) IfNoneMatch(entityTag string) *UsersDataTypesDataPointsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsListCall) Context(ctx context.Context) *UsersDataTypesDataPointsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListDataPointsResponse.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 (c *UsersDataTypesDataPointsListCall) Do(opts ...googleapi.CallOption) (*ListDataPointsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListDataPointsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *UsersDataTypesDataPointsListCall) Pages(ctx context.Context, f func(*ListDataPointsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type UsersDataTypesDataPointsPatchCall struct {
	s          *Service
	nameid     string
	datapoint  *DataPoint
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Patch: Updates a single identifiable data point. If a data point with the
// specified `name` is not found, the request will fail.
//
//   - name: Identifier. Data point name, only supported for the subset of
//     identifiable data types. For the majority of the data types, individual
//     data points do not need to be identified and this field would be empty.
//     Format: `users/{user}/dataTypes/{data_type}/dataPoints/{data_point}`
//     Example:
//     `users/abcd1234/dataTypes/sleep/dataPoints/a1b2c3d4-e5f6-7890-1234-567890ab
//     cdef` The `{user}` ID is a system-generated identifier, as described in
//     Identity.health_user_id. The `{data_type}` ID corresponds to the
//     kebab-case version of the field names in the DataPoint data union field,
//     e.g. `heart-rate` for the `heart_rate` field. The `{data_point}` ID can be
//     client-provided or system-generated. If client-provided, it must be a
//     string of 4-63 characters, containing only lowercase letters, numbers, and
//     hyphens.
func (r *UsersDataTypesDataPointsService) Patch(nameid string, datapoint *DataPoint) *UsersDataTypesDataPointsPatchCall {
	c := &UsersDataTypesDataPointsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.nameid = nameid
	c.datapoint = datapoint
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsPatchCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsPatchCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsPatchCall) Context(ctx context.Context) *UsersDataTypesDataPointsPatchCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsPatchCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsPatchCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.datapoint)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.nameid,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.patch", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.patch" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *UsersDataTypesDataPointsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.patch", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersDataTypesDataPointsReconcileCall struct {
	s            *Service
	parent       string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Reconcile: Reconcile data points from multiple data sources into a single
// data stream.
//
//   - parent: Parent data type of the Data Point collection. Format:
//     `users/me/dataTypes/{data_type}`, e.g.: - `users/me/dataTypes/steps` -
//     `users/me/dataTypes/heart-rate` For a list of the supported data types see
//     the DataPoint data union field.
func (r *UsersDataTypesDataPointsService) Reconcile(parent string) *UsersDataTypesDataPointsReconcileCall {
	c := &UsersDataTypesDataPointsReconcileCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// DataSourceFamily sets the optional parameter "dataSourceFamily": The data
// source family name to reconcile. If empty, data points from all data sources
// will be reconciled. Format:
// `users/me/dataSourceFamilies/{data_source_family}` -
// `users/me/dataSourceFamilies/all-sources` - Default value. Includes data
// from all available data sources. -
// `users/me/dataSourceFamilies/google-wearables` - Includes data from Google
// and Fitbit tracker devices (such as Fitbit trackers and Pixel Watch).
// Excludes manually logged data. -
// `users/me/dataSourceFamilies/google-sources` - Includes first-party Google
// data, such as data from tracker devices, manually logged data, and Health
// Connect.
func (c *UsersDataTypesDataPointsReconcileCall) DataSourceFamily(dataSourceFamily string) *UsersDataTypesDataPointsReconcileCall {
	c.urlParams_.Set("dataSourceFamily", dataSourceFamily)
	return c
}

// Filter sets the optional parameter "filter": Filter expression based on
// https://aip.dev/160. A time range, either physical or civil, can be
// specified. See the ListDataPointsRequest.filter for the supported fields and
// syntax.
func (c *UsersDataTypesDataPointsReconcileCall) Filter(filter string) *UsersDataTypesDataPointsReconcileCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of data
// points to return. If unspecified, at most 1440 data points will be returned.
// The maximum page size is 10000; values above that will be truncated
// accordingly. For `exercise` and `sleep` the default page size is 25. The
// maximum page size for `exercise` and `sleep` is 25.
func (c *UsersDataTypesDataPointsReconcileCall) PageSize(pageSize int64) *UsersDataTypesDataPointsReconcileCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": The `next_page_token`
// from a previous request, if any.
func (c *UsersDataTypesDataPointsReconcileCall) PageToken(pageToken string) *UsersDataTypesDataPointsReconcileCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsReconcileCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsReconcileCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersDataTypesDataPointsReconcileCall) IfNoneMatch(entityTag string) *UsersDataTypesDataPointsReconcileCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsReconcileCall) Context(ctx context.Context) *UsersDataTypesDataPointsReconcileCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsReconcileCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsReconcileCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints:reconcile")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.reconcile", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.reconcile" call.
// Any non-2xx status code is an error. Response headers are in either
// *ReconcileDataPointsResponse.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 (c *UsersDataTypesDataPointsReconcileCall) Do(opts ...googleapi.CallOption) (*ReconcileDataPointsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ReconcileDataPointsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.reconcile", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *UsersDataTypesDataPointsReconcileCall) Pages(ctx context.Context, f func(*ReconcileDataPointsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type UsersDataTypesDataPointsRollUpCall struct {
	s                       *Service
	parent                  string
	rollupdatapointsrequest *RollUpDataPointsRequest
	urlParams_              gensupport.URLParams
	ctx_                    context.Context
	header_                 http.Header
}

// RollUp: Roll up data points over physical time intervals for supported data
// types.
//
//   - parent: Parent data type of the Data Point collection. Format:
//     `users/{user}/dataTypes/{data_type}`, e.g.: - `users/me/dataTypes/steps` -
//     `users/me/dataTypes/distance` For a list of the supported data types see
//     the RollupDataPoint value union field.
func (r *UsersDataTypesDataPointsService) RollUp(parent string, rollupdatapointsrequest *RollUpDataPointsRequest) *UsersDataTypesDataPointsRollUpCall {
	c := &UsersDataTypesDataPointsRollUpCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.rollupdatapointsrequest = rollupdatapointsrequest
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersDataTypesDataPointsRollUpCall) Fields(s ...googleapi.Field) *UsersDataTypesDataPointsRollUpCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersDataTypesDataPointsRollUpCall) Context(ctx context.Context) *UsersDataTypesDataPointsRollUpCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersDataTypesDataPointsRollUpCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersDataTypesDataPointsRollUpCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.rollupdatapointsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/dataPoints:rollUp")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.rollUp", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.dataTypes.dataPoints.rollUp" call.
// Any non-2xx status code is an error. Response headers are in either
// *RollUpDataPointsResponse.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 (c *UsersDataTypesDataPointsRollUpCall) Do(opts ...googleapi.CallOption) (*RollUpDataPointsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RollUpDataPointsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.dataTypes.dataPoints.rollUp", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *UsersDataTypesDataPointsRollUpCall) Pages(ctx context.Context, f func(*RollUpDataPointsResponse) error) error {
	c.ctx_ = ctx
	defer func(pt string) { c.rollupdatapointsrequest.PageToken = pt }(c.rollupdatapointsrequest.PageToken)
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.rollupdatapointsrequest.PageToken = x.NextPageToken
	}
}

type UsersPairedDevicesGetCall struct {
	s            *Service
	name         string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Get: Returns user's Device.
//
//   - name: The name of the device to retrieve. Format:
//     users/{user}/devices/{device}.
func (r *UsersPairedDevicesService) Get(name string) *UsersPairedDevicesGetCall {
	c := &UsersPairedDevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersPairedDevicesGetCall) Fields(s ...googleapi.Field) *UsersPairedDevicesGetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersPairedDevicesGetCall) IfNoneMatch(entityTag string) *UsersPairedDevicesGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersPairedDevicesGetCall) Context(ctx context.Context) *UsersPairedDevicesGetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersPairedDevicesGetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersPairedDevicesGetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.pairedDevices.get", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.pairedDevices.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *PairedDevice.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 (c *UsersPairedDevicesGetCall) Do(opts ...googleapi.CallOption) (*PairedDevice, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PairedDevice{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.pairedDevices.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type UsersPairedDevicesListCall struct {
	s            *Service
	parent       string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Returns the user's list of paired 1P trackers and smartwatches.
//
//   - parent: The parent, which owns this collection of devices. Format:
//     users/{user}.
func (r *UsersPairedDevicesService) List(parent string) *UsersPairedDevicesListCall {
	c := &UsersPairedDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of
// devices to return. The service may return fewer than this value. If
// unspecified, at most 5 devices will be returned. The maximum value is 100.
// values above 100 will be coerced to 100.
func (c *UsersPairedDevicesListCall) PageSize(pageSize int64) *UsersPairedDevicesListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": A page token, received
// from a previous `ListPairedDevices` call. Provide this to retrieve the
// subsequent page. When paginating, all other parameters provided to
// `ListPairedDevices` must match the call that provided the page token.
func (c *UsersPairedDevicesListCall) PageToken(pageToken string) *UsersPairedDevicesListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *UsersPairedDevicesListCall) Fields(s ...googleapi.Field) *UsersPairedDevicesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *UsersPairedDevicesListCall) IfNoneMatch(entityTag string) *UsersPairedDevicesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *UsersPairedDevicesListCall) Context(ctx context.Context) *UsersPairedDevicesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *UsersPairedDevicesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *UsersPairedDevicesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v4/{+parent}/pairedDevices")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "health.users.pairedDevices.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "health.users.pairedDevices.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListPairedDevicesResponse.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 (c *UsersPairedDevicesListCall) Do(opts ...googleapi.CallOption) (*ListPairedDevicesResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListPairedDevicesResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "health.users.pairedDevices.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *UsersPairedDevicesListCall) Pages(ctx context.Context, f func(*ListPairedDevicesResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}