Copyright	(c) 2015-2016 Brendan Hay
License	Mozilla Public License, v. 2.0.
Maintainer	Brendan Hay <brendan.g.hay@gmail.com>
Stability	auto-generated
Portability	non-portable (GHC extensions)
Safe Haskell	None
Language	Haskell2010

Network.Google.Fitness.Types

Contents

Service Configuration
OAuth Scopes
AggregateBucketType
DataSet
Application
AggregateResponse
AggregateBy
DataSourceType
BucketByTimePeriodType
BucketByActivity
AggregateRequest
Device
Value
BucketBySession
DataPoint
ListSessionsResponse
AggregateBucket
MapValue
ListDataSourcesResponse
DataTypeField
AggregateRequestFilteredDataQualityStandardItem
DataSource
BucketByTimePeriod
DeviceType
ValueMapValEntry
BucketByTime
DataType
Session
DataSourceDataQualityStandardItem
DataTypeFieldFormat

Description

Synopsis

Service Configuration

fitnessService :: ServiceConfig #

Default request referring to version v1 of the Fitness. This contains the host and root path used as a starting point for constructing service requests.

OAuth Scopes

fitnessBodyTemperatureReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.body_temperature.read"] #

View body temperature data in Google Fit

fitnessBodyReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.body.read"] #

View body sensor information in Google Fit

fitnessNutritionReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.nutrition.read"] #

View nutrition information in Google Fit

fitnessReProductiveHealthReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.reproductive_health.read"] #

View reproductive health data in Google Fit

fitnessActivityReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.activity.read"] #

View your activity information in Google Fit

fitnessReProductiveHealthWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.reproductive_health.write"] #

View and store reproductive health data in Google Fit

fitnessActivityWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.activity.write"] #

View and store your activity information in Google Fit

fitnessBloodPressureWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.blood_pressure.write"] #

View and store blood pressure data in Google Fit

fitnessBodyTemperatureWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.body_temperature.write"] #

View and store body temperature data in Google Fit

fitnessOxygenSaturationReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.oxygen_saturation.read"] #

View oxygen saturation data in Google Fit

fitnessBloodGlucoseWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.blood_glucose.write"] #

View and store blood glucose data in Google Fit

fitnessBloodPressureReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.blood_pressure.read"] #

View blood pressure data in Google Fit

fitnessLocationReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.location.read"] #

View your stored location data in Google Fit

fitnessLocationWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.location.write"] #

View and store your location data in Google Fit

fitnessNutritionWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.nutrition.write"] #

View and store nutrition information in Google Fit

fitnessBodyWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.body.write"] #

View and store body sensor data in Google Fit

fitnessBloodGlucoseReadScope :: Proxy '["https://www.googleapis.com/auth/fitness.blood_glucose.read"] #

View blood glucose data in Google Fit

fitnessOxygenSaturationWriteScope :: Proxy '["https://www.googleapis.com/auth/fitness.oxygen_saturation.write"] #

View and store oxygen saturation data in Google Fit

AggregateBucketType

data AggregateBucketType #

The type of a bucket signifies how the data aggregation is performed in the bucket.

Constructors

ABTActivitySegment	activitySegment
ABTActivityType	activityType
ABTSession	session
ABTTime	time
ABTUnknown	unknown

Instances

Enum AggregateBucketType #
Methods succ :: AggregateBucketType -> AggregateBucketType # pred :: AggregateBucketType -> AggregateBucketType # toEnum :: Int -> AggregateBucketType # fromEnum :: AggregateBucketType -> Int # enumFrom :: AggregateBucketType -> [AggregateBucketType] # enumFromThen :: AggregateBucketType -> AggregateBucketType -> [AggregateBucketType] # enumFromTo :: AggregateBucketType -> AggregateBucketType -> [AggregateBucketType] # enumFromThenTo :: AggregateBucketType -> AggregateBucketType -> AggregateBucketType -> [AggregateBucketType] #
Eq AggregateBucketType #
Methods (==) :: AggregateBucketType -> AggregateBucketType -> Bool # (/=) :: AggregateBucketType -> AggregateBucketType -> Bool #
Data AggregateBucketType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateBucketType -> c AggregateBucketType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateBucketType # toConstr :: AggregateBucketType -> Constr # dataTypeOf :: AggregateBucketType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateBucketType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateBucketType) # gmapT :: (forall b. Data b => b -> b) -> AggregateBucketType -> AggregateBucketType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBucketType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBucketType -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateBucketType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateBucketType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateBucketType -> m AggregateBucketType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBucketType -> m AggregateBucketType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBucketType -> m AggregateBucketType #
Ord AggregateBucketType #
Methods compare :: AggregateBucketType -> AggregateBucketType -> Ordering # (<) :: AggregateBucketType -> AggregateBucketType -> Bool # (<=) :: AggregateBucketType -> AggregateBucketType -> Bool # (>) :: AggregateBucketType -> AggregateBucketType -> Bool # (>=) :: AggregateBucketType -> AggregateBucketType -> Bool # max :: AggregateBucketType -> AggregateBucketType -> AggregateBucketType # min :: AggregateBucketType -> AggregateBucketType -> AggregateBucketType #
Read AggregateBucketType #
Methods readsPrec :: Int -> ReadS AggregateBucketType # readList :: ReadS [AggregateBucketType] # readPrec :: ReadPrec AggregateBucketType # readListPrec :: ReadPrec [AggregateBucketType] #
Show AggregateBucketType #
Methods showsPrec :: Int -> AggregateBucketType -> ShowS # show :: AggregateBucketType -> String # showList :: [AggregateBucketType] -> ShowS #
Generic AggregateBucketType #
Associated Types type Rep AggregateBucketType :: * -> * # Methods from :: AggregateBucketType -> Rep AggregateBucketType x # to :: Rep AggregateBucketType x -> AggregateBucketType #
Hashable AggregateBucketType #
Methods hashWithSalt :: Int -> AggregateBucketType -> Int # hash :: AggregateBucketType -> Int #
ToJSON AggregateBucketType #
Methods toJSON :: AggregateBucketType -> Value # toEncoding :: AggregateBucketType -> Encoding # toJSONList :: [AggregateBucketType] -> Value # toEncodingList :: [AggregateBucketType] -> Encoding #
FromJSON AggregateBucketType #
Methods parseJSON :: Value -> Parser AggregateBucketType # parseJSONList :: Value -> Parser [AggregateBucketType] #
FromHttpApiData AggregateBucketType #
Methods parseUrlPiece :: Text -> Either Text AggregateBucketType # parseHeader :: ByteString -> Either Text AggregateBucketType # parseQueryParam :: Text -> Either Text AggregateBucketType #
ToHttpApiData AggregateBucketType #
Methods toUrlPiece :: AggregateBucketType -> Text # toEncodedUrlPiece :: AggregateBucketType -> Builder # toHeader :: AggregateBucketType -> ByteString # toQueryParam :: AggregateBucketType -> Text #
type Rep AggregateBucketType #
type Rep AggregateBucketType = D1 (MetaData "AggregateBucketType" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) ((:+:) (C1 (MetaCons "ABTActivitySegment" PrefixI False) U1) (C1 (MetaCons "ABTActivityType" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ABTSession" PrefixI False) U1) ((:+:) (C1 (MetaCons "ABTTime" PrefixI False) U1) (C1 (MetaCons "ABTUnknown" PrefixI False) U1))))

DataSet

data DataSet #

A dataset represents a projection container for data points. They do not carry any info of their own. Datasets represent a set of data points from a particular data source. A data point can be found in more than one dataset.

See: dataSet smart constructor.

Instances

Eq DataSet #
Methods (==) :: DataSet -> DataSet -> Bool # (/=) :: DataSet -> DataSet -> Bool #
Data DataSet #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataSet -> c DataSet # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataSet # toConstr :: DataSet -> Constr # dataTypeOf :: DataSet -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataSet) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataSet) # gmapT :: (forall b. Data b => b -> b) -> DataSet -> DataSet # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataSet -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataSet -> r # gmapQ :: (forall d. Data d => d -> u) -> DataSet -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataSet -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataSet -> m DataSet # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSet -> m DataSet # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSet -> m DataSet #
Show DataSet #
Methods showsPrec :: Int -> DataSet -> ShowS # show :: DataSet -> String # showList :: [DataSet] -> ShowS #
Generic DataSet #
Associated Types type Rep DataSet :: * -> * # Methods from :: DataSet -> Rep DataSet x # to :: Rep DataSet x -> DataSet #
ToJSON DataSet #
Methods toJSON :: DataSet -> Value # toEncoding :: DataSet -> Encoding # toJSONList :: [DataSet] -> Value # toEncodingList :: [DataSet] -> Encoding #
FromJSON DataSet #
Methods parseJSON :: Value -> Parser DataSet # parseJSONList :: Value -> Parser [DataSet] #
type Rep DataSet #
type Rep DataSet = D1 (MetaData "DataSet" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "DataSet'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_dsNextPageToken") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dsDataSourceId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))) ((::) (S1 (MetaSel (Just Symbol "_dsPoint") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [DataPoint]))) ((::) (S1 (MetaSel (Just Symbol "_dsMinStartTimeNs") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_dsMaxEndTimeNs") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))))))

dataSet :: DataSet #

Creates a value of DataSet with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dsNextPageToken :: Lens' DataSet (Maybe Text) #

This token will be set when a dataset is received in response to a GET request and the dataset is too large to be included in a single response. Provide this value in a subsequent GET request to return the next page of data points within this dataset.

dsDataSourceId :: Lens' DataSet (Maybe Text) #

The data stream ID of the data source that created the points in this dataset.

dsPoint :: Lens' DataSet [DataPoint] #

A partial list of data points contained in the dataset, ordered by largest endTimeNanos first. This list is considered complete when retrieving a small dataset and partial when patching a dataset or retrieving a dataset that is too large to include in a single response.

dsMinStartTimeNs :: Lens' DataSet (Maybe Int64) #

The smallest start time of all data points in this possibly partial representation of the dataset. Time is in nanoseconds from epoch. This should also match the first part of the dataset identifier.

dsMaxEndTimeNs :: Lens' DataSet (Maybe Int64) #

The largest end time of all data points in this possibly partial representation of the dataset. Time is in nanoseconds from epoch. This should also match the first part of the dataset identifier.

Application

data Application #

See: application smart constructor.

Instances

Eq Application #
Methods (==) :: Application -> Application -> Bool # (/=) :: Application -> Application -> Bool #
Data Application #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Application -> c Application # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Application # toConstr :: Application -> Constr # dataTypeOf :: Application -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Application) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Application) # gmapT :: (forall b. Data b => b -> b) -> Application -> Application # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Application -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Application -> r # gmapQ :: (forall d. Data d => d -> u) -> Application -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Application -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Application -> m Application # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Application -> m Application # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Application -> m Application #
Show Application #
Methods showsPrec :: Int -> Application -> ShowS # show :: Application -> String # showList :: [Application] -> ShowS #
Generic Application #
Associated Types type Rep Application :: * -> * # Methods from :: Application -> Rep Application x # to :: Rep Application x -> Application #
ToJSON Application #
Methods toJSON :: Application -> Value # toEncoding :: Application -> Encoding # toJSONList :: [Application] -> Value # toEncodingList :: [Application] -> Encoding #
FromJSON Application #
Methods parseJSON :: Value -> Parser Application # parseJSONList :: Value -> Parser [Application] #
type Rep Application #
type Rep Application = D1 (MetaData "Application" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "Application'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_aPackageName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_aName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))) ((:*:) (S1 (MetaSel (Just Symbol "_aVersion") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_aDetailsURL") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))))

application :: Application #

Creates a value of Application with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

aPackageName :: Lens' Application (Maybe Text) #

Package name for this application. This is used as a unique identifier when created by Android applications, but cannot be specified by REST clients. REST clients will have their developer project number reflected into the Data Source data stream IDs, instead of the packageName.

aName :: Lens' Application (Maybe Text) #

The name of this application. This is required for REST clients, but we do not enforce uniqueness of this name. It is provided as a matter of convenience for other developers who would like to identify which REST created an Application or Data Source.

aVersion :: Lens' Application (Maybe Text) #

Version of the application. You should update this field whenever the application changes in a way that affects the computation of the data.

aDetailsURL :: Lens' Application (Maybe Text) #

An optional URI that can be used to link back to the application.

AggregateResponse

data AggregateResponse #

Instances

Eq AggregateResponse #
Methods (==) :: AggregateResponse -> AggregateResponse -> Bool # (/=) :: AggregateResponse -> AggregateResponse -> Bool #
Data AggregateResponse #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateResponse -> c AggregateResponse # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateResponse # toConstr :: AggregateResponse -> Constr # dataTypeOf :: AggregateResponse -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateResponse) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateResponse) # gmapT :: (forall b. Data b => b -> b) -> AggregateResponse -> AggregateResponse # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateResponse -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateResponse -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateResponse -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateResponse -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateResponse -> m AggregateResponse # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateResponse -> m AggregateResponse # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateResponse -> m AggregateResponse #
Show AggregateResponse #
Methods showsPrec :: Int -> AggregateResponse -> ShowS # show :: AggregateResponse -> String # showList :: [AggregateResponse] -> ShowS #
Generic AggregateResponse #
Associated Types type Rep AggregateResponse :: * -> * # Methods from :: AggregateResponse -> Rep AggregateResponse x # to :: Rep AggregateResponse x -> AggregateResponse #
ToJSON AggregateResponse #
Methods toJSON :: AggregateResponse -> Value # toEncoding :: AggregateResponse -> Encoding # toJSONList :: [AggregateResponse] -> Value # toEncodingList :: [AggregateResponse] -> Encoding #
FromJSON AggregateResponse #
Methods parseJSON :: Value -> Parser AggregateResponse # parseJSONList :: Value -> Parser [AggregateResponse] #
type Rep AggregateResponse #
type Rep AggregateResponse = D1 (MetaData "AggregateResponse" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" True) (C1 (MetaCons "AggregateResponse'" PrefixI True) (S1 (MetaSel (Just Symbol "_arBucket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [AggregateBucket]))))

aggregateResponse :: AggregateResponse #

Creates a value of AggregateResponse with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

arBucket

arBucket :: Lens' AggregateResponse [AggregateBucket] #

A list of buckets containing the aggregated data.

AggregateBy

data AggregateBy #

The specification of which data to aggregate.

See: aggregateBy smart constructor.

Instances

Eq AggregateBy #
Methods (==) :: AggregateBy -> AggregateBy -> Bool # (/=) :: AggregateBy -> AggregateBy -> Bool #
Data AggregateBy #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateBy -> c AggregateBy # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateBy # toConstr :: AggregateBy -> Constr # dataTypeOf :: AggregateBy -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateBy) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateBy) # gmapT :: (forall b. Data b => b -> b) -> AggregateBy -> AggregateBy # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBy -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBy -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateBy -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateBy -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateBy -> m AggregateBy # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBy -> m AggregateBy # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBy -> m AggregateBy #
Show AggregateBy #
Methods showsPrec :: Int -> AggregateBy -> ShowS # show :: AggregateBy -> String # showList :: [AggregateBy] -> ShowS #
Generic AggregateBy #
Associated Types type Rep AggregateBy :: * -> * # Methods from :: AggregateBy -> Rep AggregateBy x # to :: Rep AggregateBy x -> AggregateBy #
ToJSON AggregateBy #
Methods toJSON :: AggregateBy -> Value # toEncoding :: AggregateBy -> Encoding # toJSONList :: [AggregateBy] -> Value # toEncodingList :: [AggregateBy] -> Encoding #
FromJSON AggregateBy #
Methods parseJSON :: Value -> Parser AggregateBy # parseJSONList :: Value -> Parser [AggregateBy] #
type Rep AggregateBy #
type Rep AggregateBy = D1 (MetaData "AggregateBy" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "AggregateBy'" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_abDataTypeName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_abDataSourceId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))))

aggregateBy :: AggregateBy #

Creates a value of AggregateBy with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

abDataTypeName
abDataSourceId

abDataTypeName :: Lens' AggregateBy (Maybe Text) #

The data type to aggregate. All data sources providing this data type will contribute data to the aggregation. The response will contain a single dataset for this data type name. The dataset will have a data source ID of derived:com.google.:com.google.android.gms:aggregated

abDataSourceId :: Lens' AggregateBy (Maybe Text) #

A data source ID to aggregate. Mutually exclusive of dataTypeName. Only data from the specified data source ID will be included in the aggregation. The dataset in the response will have the same data source ID.

DataSourceType

data DataSourceType #

A constant describing the type of this data source. Indicates whether this data source produces raw or derived data.

Constructors

Derived	derived
Raw	raw

Instances

Enum DataSourceType #
Methods succ :: DataSourceType -> DataSourceType # pred :: DataSourceType -> DataSourceType # toEnum :: Int -> DataSourceType # fromEnum :: DataSourceType -> Int # enumFrom :: DataSourceType -> [DataSourceType] # enumFromThen :: DataSourceType -> DataSourceType -> [DataSourceType] # enumFromTo :: DataSourceType -> DataSourceType -> [DataSourceType] # enumFromThenTo :: DataSourceType -> DataSourceType -> DataSourceType -> [DataSourceType] #
Eq DataSourceType #
Methods (==) :: DataSourceType -> DataSourceType -> Bool # (/=) :: DataSourceType -> DataSourceType -> Bool #
Data DataSourceType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataSourceType -> c DataSourceType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataSourceType # toConstr :: DataSourceType -> Constr # dataTypeOf :: DataSourceType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataSourceType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataSourceType) # gmapT :: (forall b. Data b => b -> b) -> DataSourceType -> DataSourceType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataSourceType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataSourceType -> r # gmapQ :: (forall d. Data d => d -> u) -> DataSourceType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataSourceType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataSourceType -> m DataSourceType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSourceType -> m DataSourceType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSourceType -> m DataSourceType #
Ord DataSourceType #
Methods compare :: DataSourceType -> DataSourceType -> Ordering # (<) :: DataSourceType -> DataSourceType -> Bool # (<=) :: DataSourceType -> DataSourceType -> Bool # (>) :: DataSourceType -> DataSourceType -> Bool # (>=) :: DataSourceType -> DataSourceType -> Bool # max :: DataSourceType -> DataSourceType -> DataSourceType # min :: DataSourceType -> DataSourceType -> DataSourceType #
Read DataSourceType #
Methods readsPrec :: Int -> ReadS DataSourceType # readList :: ReadS [DataSourceType] # readPrec :: ReadPrec DataSourceType # readListPrec :: ReadPrec [DataSourceType] #
Show DataSourceType #
Methods showsPrec :: Int -> DataSourceType -> ShowS # show :: DataSourceType -> String # showList :: [DataSourceType] -> ShowS #
Generic DataSourceType #
Associated Types type Rep DataSourceType :: * -> * # Methods from :: DataSourceType -> Rep DataSourceType x # to :: Rep DataSourceType x -> DataSourceType #
Hashable DataSourceType #
Methods hashWithSalt :: Int -> DataSourceType -> Int # hash :: DataSourceType -> Int #
ToJSON DataSourceType #
Methods toJSON :: DataSourceType -> Value # toEncoding :: DataSourceType -> Encoding # toJSONList :: [DataSourceType] -> Value # toEncodingList :: [DataSourceType] -> Encoding #
FromJSON DataSourceType #
Methods parseJSON :: Value -> Parser DataSourceType # parseJSONList :: Value -> Parser [DataSourceType] #
FromHttpApiData DataSourceType #
Methods parseUrlPiece :: Text -> Either Text DataSourceType # parseHeader :: ByteString -> Either Text DataSourceType # parseQueryParam :: Text -> Either Text DataSourceType #
ToHttpApiData DataSourceType #
Methods toUrlPiece :: DataSourceType -> Text # toEncodedUrlPiece :: DataSourceType -> Builder # toHeader :: DataSourceType -> ByteString # toQueryParam :: DataSourceType -> Text #
type Rep DataSourceType #
type Rep DataSourceType = D1 (MetaData "DataSourceType" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) (C1 (MetaCons "Derived" PrefixI False) U1) (C1 (MetaCons "Raw" PrefixI False) U1))

BucketByTimePeriodType

data BucketByTimePeriodType #

Constructors

Day	day
Month	month
Week	week

Instances

Enum BucketByTimePeriodType #
Methods succ :: BucketByTimePeriodType -> BucketByTimePeriodType # pred :: BucketByTimePeriodType -> BucketByTimePeriodType # toEnum :: Int -> BucketByTimePeriodType # fromEnum :: BucketByTimePeriodType -> Int # enumFrom :: BucketByTimePeriodType -> [BucketByTimePeriodType] # enumFromThen :: BucketByTimePeriodType -> BucketByTimePeriodType -> [BucketByTimePeriodType] # enumFromTo :: BucketByTimePeriodType -> BucketByTimePeriodType -> [BucketByTimePeriodType] # enumFromThenTo :: BucketByTimePeriodType -> BucketByTimePeriodType -> BucketByTimePeriodType -> [BucketByTimePeriodType] #
Eq BucketByTimePeriodType #
Methods (==) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool # (/=) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool #
Data BucketByTimePeriodType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BucketByTimePeriodType -> c BucketByTimePeriodType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BucketByTimePeriodType # toConstr :: BucketByTimePeriodType -> Constr # dataTypeOf :: BucketByTimePeriodType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c BucketByTimePeriodType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BucketByTimePeriodType) # gmapT :: (forall b. Data b => b -> b) -> BucketByTimePeriodType -> BucketByTimePeriodType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTimePeriodType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTimePeriodType -> r # gmapQ :: (forall d. Data d => d -> u) -> BucketByTimePeriodType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BucketByTimePeriodType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BucketByTimePeriodType -> m BucketByTimePeriodType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTimePeriodType -> m BucketByTimePeriodType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTimePeriodType -> m BucketByTimePeriodType #
Ord BucketByTimePeriodType #
Methods compare :: BucketByTimePeriodType -> BucketByTimePeriodType -> Ordering # (<) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool # (<=) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool # (>) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool # (>=) :: BucketByTimePeriodType -> BucketByTimePeriodType -> Bool # max :: BucketByTimePeriodType -> BucketByTimePeriodType -> BucketByTimePeriodType # min :: BucketByTimePeriodType -> BucketByTimePeriodType -> BucketByTimePeriodType #
Read BucketByTimePeriodType #
Methods readsPrec :: Int -> ReadS BucketByTimePeriodType # readList :: ReadS [BucketByTimePeriodType] # readPrec :: ReadPrec BucketByTimePeriodType # readListPrec :: ReadPrec [BucketByTimePeriodType] #
Show BucketByTimePeriodType #
Methods showsPrec :: Int -> BucketByTimePeriodType -> ShowS # show :: BucketByTimePeriodType -> String # showList :: [BucketByTimePeriodType] -> ShowS #
Generic BucketByTimePeriodType #
Associated Types type Rep BucketByTimePeriodType :: * -> * # Methods from :: BucketByTimePeriodType -> Rep BucketByTimePeriodType x # to :: Rep BucketByTimePeriodType x -> BucketByTimePeriodType #
Hashable BucketByTimePeriodType #
Methods hashWithSalt :: Int -> BucketByTimePeriodType -> Int # hash :: BucketByTimePeriodType -> Int #
ToJSON BucketByTimePeriodType #
Methods toJSON :: BucketByTimePeriodType -> Value # toEncoding :: BucketByTimePeriodType -> Encoding # toJSONList :: [BucketByTimePeriodType] -> Value # toEncodingList :: [BucketByTimePeriodType] -> Encoding #
FromJSON BucketByTimePeriodType #
Methods parseJSON :: Value -> Parser BucketByTimePeriodType # parseJSONList :: Value -> Parser [BucketByTimePeriodType] #
FromHttpApiData BucketByTimePeriodType #
Methods parseUrlPiece :: Text -> Either Text BucketByTimePeriodType # parseHeader :: ByteString -> Either Text BucketByTimePeriodType # parseQueryParam :: Text -> Either Text BucketByTimePeriodType #
ToHttpApiData BucketByTimePeriodType #
Methods toUrlPiece :: BucketByTimePeriodType -> Text # toEncodedUrlPiece :: BucketByTimePeriodType -> Builder # toHeader :: BucketByTimePeriodType -> ByteString # toQueryParam :: BucketByTimePeriodType -> Text #
type Rep BucketByTimePeriodType #
type Rep BucketByTimePeriodType = D1 (MetaData "BucketByTimePeriodType" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) (C1 (MetaCons "Day" PrefixI False) U1) ((:+:) (C1 (MetaCons "Month" PrefixI False) U1) (C1 (MetaCons "Week" PrefixI False) U1)))

BucketByActivity

data BucketByActivity #

Instances

Eq BucketByActivity #
Methods (==) :: BucketByActivity -> BucketByActivity -> Bool # (/=) :: BucketByActivity -> BucketByActivity -> Bool #
Data BucketByActivity #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BucketByActivity -> c BucketByActivity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BucketByActivity # toConstr :: BucketByActivity -> Constr # dataTypeOf :: BucketByActivity -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c BucketByActivity) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BucketByActivity) # gmapT :: (forall b. Data b => b -> b) -> BucketByActivity -> BucketByActivity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BucketByActivity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BucketByActivity -> r # gmapQ :: (forall d. Data d => d -> u) -> BucketByActivity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BucketByActivity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BucketByActivity -> m BucketByActivity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByActivity -> m BucketByActivity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByActivity -> m BucketByActivity #
Show BucketByActivity #
Methods showsPrec :: Int -> BucketByActivity -> ShowS # show :: BucketByActivity -> String # showList :: [BucketByActivity] -> ShowS #
Generic BucketByActivity #
Associated Types type Rep BucketByActivity :: * -> * # Methods from :: BucketByActivity -> Rep BucketByActivity x # to :: Rep BucketByActivity x -> BucketByActivity #
ToJSON BucketByActivity #
Methods toJSON :: BucketByActivity -> Value # toEncoding :: BucketByActivity -> Encoding # toJSONList :: [BucketByActivity] -> Value # toEncodingList :: [BucketByActivity] -> Encoding #
FromJSON BucketByActivity #
Methods parseJSON :: Value -> Parser BucketByActivity # parseJSONList :: Value -> Parser [BucketByActivity] #
type Rep BucketByActivity #
type Rep BucketByActivity = D1 (MetaData "BucketByActivity" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "BucketByActivity'" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_bbaMinDurationMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_bbaActivityDataSourceId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))))

bucketByActivity :: BucketByActivity #

Creates a value of BucketByActivity with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

bbaMinDurationMillis :: Lens' BucketByActivity (Maybe Int64) #

Specifies that only activity segments of duration longer than minDurationMillis are considered and used as a container for aggregated data.

bbaActivityDataSourceId :: Lens' BucketByActivity (Maybe Text) #

The default activity stream will be used if a specific activityDataSourceId is not specified.

AggregateRequest

data AggregateRequest #

Next id: 10

See: aggregateRequest smart constructor.

Instances

Eq AggregateRequest #
Methods (==) :: AggregateRequest -> AggregateRequest -> Bool # (/=) :: AggregateRequest -> AggregateRequest -> Bool #
Data AggregateRequest #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateRequest -> c AggregateRequest # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateRequest # toConstr :: AggregateRequest -> Constr # dataTypeOf :: AggregateRequest -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateRequest) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateRequest) # gmapT :: (forall b. Data b => b -> b) -> AggregateRequest -> AggregateRequest # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateRequest -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateRequest -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateRequest -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateRequest -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateRequest -> m AggregateRequest # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateRequest -> m AggregateRequest # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateRequest -> m AggregateRequest #
Show AggregateRequest #
Methods showsPrec :: Int -> AggregateRequest -> ShowS # show :: AggregateRequest -> String # showList :: [AggregateRequest] -> ShowS #
Generic AggregateRequest #
Associated Types type Rep AggregateRequest :: * -> * # Methods from :: AggregateRequest -> Rep AggregateRequest x # to :: Rep AggregateRequest x -> AggregateRequest #
ToJSON AggregateRequest #
Methods toJSON :: AggregateRequest -> Value # toEncoding :: AggregateRequest -> Encoding # toJSONList :: [AggregateRequest] -> Value # toEncodingList :: [AggregateRequest] -> Encoding #
FromJSON AggregateRequest #
Methods parseJSON :: Value -> Parser AggregateRequest # parseJSONList :: Value -> Parser [AggregateRequest] #
type Rep AggregateRequest #
type Rep AggregateRequest = D1 (MetaData "AggregateRequest" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "AggregateRequest'" PrefixI True) ((::) ((::) ((::) (S1 (MetaSel (Just Symbol "_arEndTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_arFilteredDataQualityStandard") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [AggregateRequestFilteredDataQualityStandardItem])))) ((::) (S1 (MetaSel (Just Symbol "_arAggregateBy") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [AggregateBy]))) (S1 (MetaSel (Just Symbol "_arBucketBySession") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketBySession))))) ((::) ((::) (S1 (MetaSel (Just Symbol "_arBucketByActivityType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketByActivity))) (S1 (MetaSel (Just Symbol "_arBucketByTime") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketByTime)))) ((:*:) (S1 (MetaSel (Just Symbol "_arStartTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_arBucketByActivitySegment") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketByActivity)))))))

aggregateRequest :: AggregateRequest #

Creates a value of AggregateRequest with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

arEndTimeMillis :: Lens' AggregateRequest (Maybe Int64) #

The end of a window of time. Data that intersects with this time window will be aggregated. The time is in milliseconds since epoch, inclusive.

arFilteredDataQualityStandard :: Lens' AggregateRequest [AggregateRequestFilteredDataQualityStandardItem] #

A list of acceptable data quality standards. Only data points which conform to at least one of the specified data quality standards will be returned. If the list is empty, all data points are returned.

arAggregateBy :: Lens' AggregateRequest [AggregateBy] #

The specification of data to be aggregated. At least one aggregateBy spec must be provided. All data that is specified will be aggregated using the same bucketing criteria. There will be one dataset in the response for every aggregateBy spec.

arBucketBySession :: Lens' AggregateRequest (Maybe BucketBySession) #

Specifies that data be aggregated by user sessions. Data that does not fall within the time range of a session will not be included in the response. Mutually exclusive of other bucketing specifications.

arBucketByActivityType :: Lens' AggregateRequest (Maybe BucketByActivity) #

Specifies that data be aggregated by the type of activity being performed when the data was recorded. All data that was recorded during a certain activity type (for the given time range) will be aggregated into the same bucket. Data that was recorded while the user was not active will not be included in the response. Mutually exclusive of other bucketing specifications.

arBucketByTime :: Lens' AggregateRequest (Maybe BucketByTime) #

Specifies that data be aggregated by a single time interval. Mutually exclusive of other bucketing specifications.

arStartTimeMillis :: Lens' AggregateRequest (Maybe Int64) #

The start of a window of time. Data that intersects with this time window will be aggregated. The time is in milliseconds since epoch, inclusive.

arBucketByActivitySegment :: Lens' AggregateRequest (Maybe BucketByActivity) #

Specifies that data be aggregated each activity segment recored for a user. Similar to bucketByActivitySegment, but bucketing is done for each activity segment rather than all segments of the same type. Mutually exclusive of other bucketing specifications.

Device

data Device #

Representation of an integrated device (such as a phone or a wearable) that can hold sensors. Each sensor is exposed as a data source. The main purpose of the device information contained in this class is to identify the hardware of a particular data source. This can be useful in different ways, including: - Distinguishing two similar sensors on different devices (the step counter on two nexus 5 phones, for instance) - Display the source of data to the user (by using the device make / model) - Treat data differently depending on sensor type (accelerometers on a watch may give different patterns than those on a phone) - Build different analysis models for each device/version.

See: device smart constructor.

Instances

Eq Device #
Methods (==) :: Device -> Device -> Bool # (/=) :: Device -> Device -> Bool #
Data Device #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Device -> c Device # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Device # toConstr :: Device -> Constr # dataTypeOf :: Device -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Device) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Device) # gmapT :: (forall b. Data b => b -> b) -> Device -> Device # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Device -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Device -> r # gmapQ :: (forall d. Data d => d -> u) -> Device -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Device -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Device -> m Device # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Device -> m Device # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Device -> m Device #
Show Device #
Methods showsPrec :: Int -> Device -> ShowS # show :: Device -> String # showList :: [Device] -> ShowS #
Generic Device #
Associated Types type Rep Device :: * -> * # Methods from :: Device -> Rep Device x # to :: Rep Device x -> Device #
ToJSON Device #
Methods toJSON :: Device -> Value # toEncoding :: Device -> Encoding # toJSONList :: [Device] -> Value # toEncodingList :: [Device] -> Encoding #
FromJSON Device #
Methods parseJSON :: Value -> Parser Device # parseJSONList :: Value -> Parser [Device] #
type Rep Device #
type Rep Device = D1 (MetaData "Device" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "Device'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_dManufacturer") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dUid") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))) ((::) (S1 (MetaSel (Just Symbol "_dModel") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) ((::) (S1 (MetaSel (Just Symbol "_dVersion") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DeviceType)))))))

device :: Device #

Creates a value of Device with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dManufacturer :: Lens' Device (Maybe Text) #

Manufacturer of the product/hardware.

dUid :: Lens' Device (Maybe Text) #

The serial number or other unique ID for the hardware. This field is obfuscated when read by any REST or Android client that did not create the data source. Only the data source creator will see the uid field in clear and normal form.

dModel :: Lens' Device (Maybe Text) #

End-user visible model name for the device.

dVersion :: Lens' Device (Maybe Text) #

Version string for the device hardware/software.

dType :: Lens' Device (Maybe DeviceType) #

A constant representing the type of the device.

Value

data Value #

Holder object for the value of a single field in a data point. A field value has a particular format and is only ever set to one of an integer or a floating point value. LINT.IfChange

See: value smart constructor.

Instances

Eq Value #
Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Data Value #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Show Value #
Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
Generic Value #
Associated Types type Rep Value :: * -> * # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
ToJSON Value #
Methods toJSON :: Value -> Value # toEncoding :: Value -> Encoding # toJSONList :: [Value] -> Value # toEncodingList :: [Value] -> Encoding #
FromJSON Value #
Methods parseJSON :: Value -> Parser Value # parseJSONList :: Value -> Parser [Value] #
type Rep Value #
type Rep Value = D1 (MetaData "Value" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "Value'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_vMapVal") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [ValueMapValEntry]))) (S1 (MetaSel (Just Symbol "_vFpVal") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Double))))) ((:*:) (S1 (MetaSel (Just Symbol "_vIntVal") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32)))) (S1 (MetaSel (Just Symbol "_vStringVal") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))))

value :: Value #

Creates a value of Value with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

vMapVal :: Lens' Value [ValueMapValEntry] #

Map value. The valid key space and units for the corresponding value of each entry should be documented as part of the data type definition. Keys should be kept small whenever possible. Data streams with large keys and high data frequency may be down sampled.

vFpVal :: Lens' Value (Maybe Double) #

Floating point value. When this is set, other values must not be set.

vIntVal :: Lens' Value (Maybe Int32) #

Integer value. When this is set, other values must not be set.

vStringVal :: Lens' Value (Maybe Text) #

String value. When this is set, other values must not be set. Strings should be kept small whenever possible. Data streams with large string values and high data frequency may be down sampled.

BucketBySession

data BucketBySession #

Instances

Eq BucketBySession #
Methods (==) :: BucketBySession -> BucketBySession -> Bool # (/=) :: BucketBySession -> BucketBySession -> Bool #
Data BucketBySession #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BucketBySession -> c BucketBySession # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BucketBySession # toConstr :: BucketBySession -> Constr # dataTypeOf :: BucketBySession -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c BucketBySession) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BucketBySession) # gmapT :: (forall b. Data b => b -> b) -> BucketBySession -> BucketBySession # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BucketBySession -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BucketBySession -> r # gmapQ :: (forall d. Data d => d -> u) -> BucketBySession -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BucketBySession -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BucketBySession -> m BucketBySession # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketBySession -> m BucketBySession # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketBySession -> m BucketBySession #
Show BucketBySession #
Methods showsPrec :: Int -> BucketBySession -> ShowS # show :: BucketBySession -> String # showList :: [BucketBySession] -> ShowS #
Generic BucketBySession #
Associated Types type Rep BucketBySession :: * -> * # Methods from :: BucketBySession -> Rep BucketBySession x # to :: Rep BucketBySession x -> BucketBySession #
ToJSON BucketBySession #
Methods toJSON :: BucketBySession -> Value # toEncoding :: BucketBySession -> Encoding # toJSONList :: [BucketBySession] -> Value # toEncodingList :: [BucketBySession] -> Encoding #
FromJSON BucketBySession #
Methods parseJSON :: Value -> Parser BucketBySession # parseJSONList :: Value -> Parser [BucketBySession] #
type Rep BucketBySession #
type Rep BucketBySession = D1 (MetaData "BucketBySession" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" True) (C1 (MetaCons "BucketBySession'" PrefixI True) (S1 (MetaSel (Just Symbol "_bbsMinDurationMillis") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Textual Int64)))))

bucketBySession :: BucketBySession #

Creates a value of BucketBySession with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

bbsMinDurationMillis

bbsMinDurationMillis :: Lens' BucketBySession (Maybe Int64) #

Specifies that only sessions of duration longer than minDurationMillis are considered and used as a container for aggregated data.

DataPoint

data DataPoint #

Represents a single data point, generated by a particular data source. A data point holds a value for each field, an end timestamp and an optional start time. The exact semantics of each of these attributes are specified in the documentation for the particular data type. A data point can represent an instantaneous measurement, reading or input observation, as well as averages or aggregates over a time interval. Check the data type documentation to determine which is the case for a particular data type. Data points always contain one value for each field of the data type.

See: dataPoint smart constructor.

Instances

Eq DataPoint #
Methods (==) :: DataPoint -> DataPoint -> Bool # (/=) :: DataPoint -> DataPoint -> Bool #
Data DataPoint #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataPoint -> c DataPoint # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataPoint # toConstr :: DataPoint -> Constr # dataTypeOf :: DataPoint -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataPoint) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataPoint) # gmapT :: (forall b. Data b => b -> b) -> DataPoint -> DataPoint # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataPoint -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataPoint -> r # gmapQ :: (forall d. Data d => d -> u) -> DataPoint -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataPoint -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataPoint -> m DataPoint # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataPoint -> m DataPoint # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataPoint -> m DataPoint #
Show DataPoint #
Methods showsPrec :: Int -> DataPoint -> ShowS # show :: DataPoint -> String # showList :: [DataPoint] -> ShowS #
Generic DataPoint #
Associated Types type Rep DataPoint :: * -> * # Methods from :: DataPoint -> Rep DataPoint x # to :: Rep DataPoint x -> DataPoint #
ToJSON DataPoint #
Methods toJSON :: DataPoint -> Value # toEncoding :: DataPoint -> Encoding # toJSONList :: [DataPoint] -> Value # toEncodingList :: [DataPoint] -> Encoding #
FromJSON DataPoint #
Methods parseJSON :: Value -> Parser DataPoint # parseJSONList :: Value -> Parser [DataPoint] #
type Rep DataPoint #
type Rep DataPoint = D1 (MetaData "DataPoint" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "DataPoint'" PrefixI True) ((::) ((::) ((::) (S1 (MetaSel (Just Symbol "_dpOriginDataSourceId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dpRawTimestampNanos") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))) ((::) (S1 (MetaSel (Just Symbol "_dpDataTypeName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dpValue") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [Value]))))) ((::) ((::) (S1 (MetaSel (Just Symbol "_dpComputationTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_dpEndTimeNanos") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))) ((:*:) (S1 (MetaSel (Just Symbol "_dpModifiedTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_dpStartTimeNanos") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))))))

dataPoint :: DataPoint #

Creates a value of DataPoint with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dpOriginDataSourceId :: Lens' DataPoint (Maybe Text) #

If the data point is contained in a dataset for a derived data source, this field will be populated with the data source stream ID that created the data point originally.

dpRawTimestampNanos :: Lens' DataPoint (Maybe Int64) #

The raw timestamp from the original SensorEvent.

dpDataTypeName :: Lens' DataPoint (Maybe Text) #

The data type defining the format of the values in this data point.

dpValue :: Lens' DataPoint [Value] #

Values of each data type field for the data point. It is expected that each value corresponding to a data type field will occur in the same order that the field is listed with in the data type specified in a data source. Only one of integer and floating point fields will be populated, depending on the format enum value within data source's type field.

dpComputationTimeMillis :: Lens' DataPoint (Maybe Int64) #

Used for version checking during transformation; that is, a datapoint can only replace another datapoint that has an older computation time stamp.

dpEndTimeNanos :: Lens' DataPoint (Maybe Int64) #

The end time of the interval represented by this data point, in nanoseconds since epoch.

dpModifiedTimeMillis :: Lens' DataPoint (Maybe Int64) #

Indicates the last time this data point was modified. Useful only in contexts where we are listing the data changes, rather than representing the current state of the data.

dpStartTimeNanos :: Lens' DataPoint (Maybe Int64) #

The start time of the interval represented by this data point, in nanoseconds since epoch.

ListSessionsResponse

data ListSessionsResponse #

Instances

Eq ListSessionsResponse #
Methods (==) :: ListSessionsResponse -> ListSessionsResponse -> Bool # (/=) :: ListSessionsResponse -> ListSessionsResponse -> Bool #
Data ListSessionsResponse #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListSessionsResponse -> c ListSessionsResponse # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ListSessionsResponse # toConstr :: ListSessionsResponse -> Constr # dataTypeOf :: ListSessionsResponse -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ListSessionsResponse) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListSessionsResponse) # gmapT :: (forall b. Data b => b -> b) -> ListSessionsResponse -> ListSessionsResponse # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListSessionsResponse -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListSessionsResponse -> r # gmapQ :: (forall d. Data d => d -> u) -> ListSessionsResponse -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListSessionsResponse -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListSessionsResponse -> m ListSessionsResponse # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListSessionsResponse -> m ListSessionsResponse # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListSessionsResponse -> m ListSessionsResponse #
Show ListSessionsResponse #
Methods showsPrec :: Int -> ListSessionsResponse -> ShowS # show :: ListSessionsResponse -> String # showList :: [ListSessionsResponse] -> ShowS #
Generic ListSessionsResponse #
Associated Types type Rep ListSessionsResponse :: * -> * # Methods from :: ListSessionsResponse -> Rep ListSessionsResponse x # to :: Rep ListSessionsResponse x -> ListSessionsResponse #
ToJSON ListSessionsResponse #
Methods toJSON :: ListSessionsResponse -> Value # toEncoding :: ListSessionsResponse -> Encoding # toJSONList :: [ListSessionsResponse] -> Value # toEncodingList :: [ListSessionsResponse] -> Encoding #
FromJSON ListSessionsResponse #
Methods parseJSON :: Value -> Parser ListSessionsResponse # parseJSONList :: Value -> Parser [ListSessionsResponse] #
type Rep ListSessionsResponse #
type Rep ListSessionsResponse = D1 (MetaData "ListSessionsResponse" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "ListSessionsResponse'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_lsrNextPageToken") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_lsrDeletedSession") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [Session])))) ((:*:) (S1 (MetaSel (Just Symbol "_lsrHasMoreData") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool))) (S1 (MetaSel (Just Symbol "_lsrSession") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [Session]))))))

listSessionsResponse :: ListSessionsResponse #

Creates a value of ListSessionsResponse with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

lsrNextPageToken :: Lens' ListSessionsResponse (Maybe Text) #

The continuation token, which is used to page through large result sets. Provide this value in a subsequent request to return the next page of results.

lsrDeletedSession :: Lens' ListSessionsResponse [Session] #

If includeDeleted is set to true in the request, this list will contain sessions deleted with original end times that are within the startTime and endTime frame.

lsrHasMoreData :: Lens' ListSessionsResponse (Maybe Bool) #

Flag to indicate server has more data to transfer

lsrSession :: Lens' ListSessionsResponse [Session] #

Sessions with an end time that is between startTime and endTime of the request.

AggregateBucket

data AggregateBucket #

Instances

Eq AggregateBucket #
Methods (==) :: AggregateBucket -> AggregateBucket -> Bool # (/=) :: AggregateBucket -> AggregateBucket -> Bool #
Data AggregateBucket #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateBucket -> c AggregateBucket # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateBucket # toConstr :: AggregateBucket -> Constr # dataTypeOf :: AggregateBucket -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateBucket) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateBucket) # gmapT :: (forall b. Data b => b -> b) -> AggregateBucket -> AggregateBucket # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBucket -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateBucket -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateBucket -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateBucket -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateBucket -> m AggregateBucket # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBucket -> m AggregateBucket # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateBucket -> m AggregateBucket #
Show AggregateBucket #
Methods showsPrec :: Int -> AggregateBucket -> ShowS # show :: AggregateBucket -> String # showList :: [AggregateBucket] -> ShowS #
Generic AggregateBucket #
Associated Types type Rep AggregateBucket :: * -> * # Methods from :: AggregateBucket -> Rep AggregateBucket x # to :: Rep AggregateBucket x -> AggregateBucket #
ToJSON AggregateBucket #
Methods toJSON :: AggregateBucket -> Value # toEncoding :: AggregateBucket -> Encoding # toJSONList :: [AggregateBucket] -> Value # toEncodingList :: [AggregateBucket] -> Encoding #
FromJSON AggregateBucket #
Methods parseJSON :: Value -> Parser AggregateBucket # parseJSONList :: Value -> Parser [AggregateBucket] #
type Rep AggregateBucket #
type Rep AggregateBucket = D1 (MetaData "AggregateBucket" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "AggregateBucket'" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "_abEndTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) ((::) (S1 (MetaSel (Just Symbol "_abDataSet") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [DataSet]))) (S1 (MetaSel (Just Symbol "_abActivity") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32)))))) ((::) (S1 (MetaSel (Just Symbol "_abType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe AggregateBucketType))) ((:*:) (S1 (MetaSel (Just Symbol "_abStartTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_abSession") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Session)))))))

aggregateBucket :: AggregateBucket #

Creates a value of AggregateBucket with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

abEndTimeMillis :: Lens' AggregateBucket (Maybe Int64) #

The end time for the aggregated data, in milliseconds since epoch, inclusive.

abDataSet :: Lens' AggregateBucket [DataSet] #

There will be one dataset per AggregateBy in the request.

abActivity :: Lens' AggregateBucket (Maybe Int32) #

Available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT

abType :: Lens' AggregateBucket (Maybe AggregateBucketType) #

The type of a bucket signifies how the data aggregation is performed in the bucket.

abStartTimeMillis :: Lens' AggregateBucket (Maybe Int64) #

The start time for the aggregated data, in milliseconds since epoch, inclusive.

abSession :: Lens' AggregateBucket (Maybe Session) #

Available for Bucket.Type.SESSION

MapValue

data MapValue #

Holder object for the value of an entry in a map field of a data point. A map value supports a subset of the formats that the regular Value supports.

See: mapValue smart constructor.

Instances

Eq MapValue #
Methods (==) :: MapValue -> MapValue -> Bool # (/=) :: MapValue -> MapValue -> Bool #
Data MapValue #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MapValue -> c MapValue # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MapValue # toConstr :: MapValue -> Constr # dataTypeOf :: MapValue -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c MapValue) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MapValue) # gmapT :: (forall b. Data b => b -> b) -> MapValue -> MapValue # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MapValue -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MapValue -> r # gmapQ :: (forall d. Data d => d -> u) -> MapValue -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MapValue -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MapValue -> m MapValue # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MapValue -> m MapValue # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MapValue -> m MapValue #
Show MapValue #
Methods showsPrec :: Int -> MapValue -> ShowS # show :: MapValue -> String # showList :: [MapValue] -> ShowS #
Generic MapValue #
Associated Types type Rep MapValue :: * -> * # Methods from :: MapValue -> Rep MapValue x # to :: Rep MapValue x -> MapValue #
ToJSON MapValue #
Methods toJSON :: MapValue -> Value # toEncoding :: MapValue -> Encoding # toJSONList :: [MapValue] -> Value # toEncodingList :: [MapValue] -> Encoding #
FromJSON MapValue #
Methods parseJSON :: Value -> Parser MapValue # parseJSONList :: Value -> Parser [MapValue] #
type Rep MapValue #
type Rep MapValue = D1 (MetaData "MapValue" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" True) (C1 (MetaCons "MapValue'" PrefixI True) (S1 (MetaSel (Just Symbol "_mvFpVal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Textual Double)))))

mapValue :: MapValue #

Creates a value of MapValue with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

mvFpVal

mvFpVal :: Lens' MapValue (Maybe Double) #

Floating point value.

ListDataSourcesResponse

data ListDataSourcesResponse #

Instances

Eq ListDataSourcesResponse #
Methods (==) :: ListDataSourcesResponse -> ListDataSourcesResponse -> Bool # (/=) :: ListDataSourcesResponse -> ListDataSourcesResponse -> Bool #
Data ListDataSourcesResponse #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListDataSourcesResponse -> c ListDataSourcesResponse # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ListDataSourcesResponse # toConstr :: ListDataSourcesResponse -> Constr # dataTypeOf :: ListDataSourcesResponse -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ListDataSourcesResponse) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ListDataSourcesResponse) # gmapT :: (forall b. Data b => b -> b) -> ListDataSourcesResponse -> ListDataSourcesResponse # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListDataSourcesResponse -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListDataSourcesResponse -> r # gmapQ :: (forall d. Data d => d -> u) -> ListDataSourcesResponse -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListDataSourcesResponse -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListDataSourcesResponse -> m ListDataSourcesResponse # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListDataSourcesResponse -> m ListDataSourcesResponse # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListDataSourcesResponse -> m ListDataSourcesResponse #
Show ListDataSourcesResponse #
Methods showsPrec :: Int -> ListDataSourcesResponse -> ShowS # show :: ListDataSourcesResponse -> String # showList :: [ListDataSourcesResponse] -> ShowS #
Generic ListDataSourcesResponse #
Associated Types type Rep ListDataSourcesResponse :: * -> * # Methods from :: ListDataSourcesResponse -> Rep ListDataSourcesResponse x # to :: Rep ListDataSourcesResponse x -> ListDataSourcesResponse #
ToJSON ListDataSourcesResponse #
Methods toJSON :: ListDataSourcesResponse -> Value # toEncoding :: ListDataSourcesResponse -> Encoding # toJSONList :: [ListDataSourcesResponse] -> Value # toEncodingList :: [ListDataSourcesResponse] -> Encoding #
FromJSON ListDataSourcesResponse #
Methods parseJSON :: Value -> Parser ListDataSourcesResponse # parseJSONList :: Value -> Parser [ListDataSourcesResponse] #
type Rep ListDataSourcesResponse #
type Rep ListDataSourcesResponse = D1 (MetaData "ListDataSourcesResponse" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" True) (C1 (MetaCons "ListDataSourcesResponse'" PrefixI True) (S1 (MetaSel (Just Symbol "_ldsrDataSource") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [DataSource]))))

listDataSourcesResponse :: ListDataSourcesResponse #

Creates a value of ListDataSourcesResponse with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

ldsrDataSource

ldsrDataSource :: Lens' ListDataSourcesResponse [DataSource] #

A previously created data source.

DataTypeField

data DataTypeField #

In case of multi-dimensional data (such as an accelerometer with x, y, and z axes) each field represents one dimension. Each data type field has a unique name which identifies it. The field also defines the format of the data (int, float, etc.). This message is only instantiated in code and not used for wire comms or stored in any way.

See: dataTypeField smart constructor.

Instances

Eq DataTypeField #
Methods (==) :: DataTypeField -> DataTypeField -> Bool # (/=) :: DataTypeField -> DataTypeField -> Bool #
Data DataTypeField #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataTypeField -> c DataTypeField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataTypeField # toConstr :: DataTypeField -> Constr # dataTypeOf :: DataTypeField -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataTypeField) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataTypeField) # gmapT :: (forall b. Data b => b -> b) -> DataTypeField -> DataTypeField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataTypeField -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataTypeField -> r # gmapQ :: (forall d. Data d => d -> u) -> DataTypeField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataTypeField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataTypeField -> m DataTypeField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataTypeField -> m DataTypeField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataTypeField -> m DataTypeField #
Show DataTypeField #
Methods showsPrec :: Int -> DataTypeField -> ShowS # show :: DataTypeField -> String # showList :: [DataTypeField] -> ShowS #
Generic DataTypeField #
Associated Types type Rep DataTypeField :: * -> * # Methods from :: DataTypeField -> Rep DataTypeField x # to :: Rep DataTypeField x -> DataTypeField #
ToJSON DataTypeField #
Methods toJSON :: DataTypeField -> Value # toEncoding :: DataTypeField -> Encoding # toJSONList :: [DataTypeField] -> Value # toEncodingList :: [DataTypeField] -> Encoding #
FromJSON DataTypeField #
Methods parseJSON :: Value -> Parser DataTypeField # parseJSONList :: Value -> Parser [DataTypeField] #
type Rep DataTypeField #
type Rep DataTypeField = D1 (MetaData "DataTypeField" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "DataTypeField'" PrefixI True) ((::) (S1 (MetaSel (Just Symbol "_dtfFormat") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DataTypeFieldFormat))) ((::) (S1 (MetaSel (Just Symbol "_dtfName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dtfOptional") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Bool))))))

dataTypeField :: DataTypeField #

Creates a value of DataTypeField with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dtfFormat :: Lens' DataTypeField (Maybe DataTypeFieldFormat) #

The different supported formats for each field in a data type.

dtfName :: Lens' DataTypeField (Maybe Text) #

Defines the name and format of data. Unlike data type names, field names are not namespaced, and only need to be unique within the data type.

dtfOptional :: Lens' DataTypeField (Maybe Bool) #

AggregateRequestFilteredDataQualityStandardItem

data AggregateRequestFilteredDataQualityStandardItem #

Constructors

DATAQUALITYBLOODGLUCOSEISO151972003	dataQualityBloodGlucoseIso151972003
DATAQUALITYBLOODGLUCOSEISO151972013	dataQualityBloodGlucoseIso151972013
DataQualityBloodPressureAami	dataQualityBloodPressureAami
DataQualityBloodPressureBhsAA	dataQualityBloodPressureBhsAA
DataQualityBloodPressureBhsAB	dataQualityBloodPressureBhsAB
DataQualityBloodPressureBhsBA	dataQualityBloodPressureBhsBA
DataQualityBloodPressureBhsBB	dataQualityBloodPressureBhsBB
DATAQUALITYBLOODPRESSUREESH2002	dataQualityBloodPressureEsh2002
DATAQUALITYBLOODPRESSUREESH2010	dataQualityBloodPressureEsh2010
DataQualityUnknown	dataQualityUnknown

Instances

Enum AggregateRequestFilteredDataQualityStandardItem #
Methods succ :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem # pred :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem # toEnum :: Int -> AggregateRequestFilteredDataQualityStandardItem # fromEnum :: AggregateRequestFilteredDataQualityStandardItem -> Int # enumFrom :: AggregateRequestFilteredDataQualityStandardItem -> [AggregateRequestFilteredDataQualityStandardItem] # enumFromThen :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> [AggregateRequestFilteredDataQualityStandardItem] # enumFromTo :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> [AggregateRequestFilteredDataQualityStandardItem] # enumFromThenTo :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> [AggregateRequestFilteredDataQualityStandardItem] #
Eq AggregateRequestFilteredDataQualityStandardItem #
Methods (==) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool # (/=) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool #
Data AggregateRequestFilteredDataQualityStandardItem #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AggregateRequestFilteredDataQualityStandardItem -> c AggregateRequestFilteredDataQualityStandardItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AggregateRequestFilteredDataQualityStandardItem # toConstr :: AggregateRequestFilteredDataQualityStandardItem -> Constr # dataTypeOf :: AggregateRequestFilteredDataQualityStandardItem -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c AggregateRequestFilteredDataQualityStandardItem) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AggregateRequestFilteredDataQualityStandardItem) # gmapT :: (forall b. Data b => b -> b) -> AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AggregateRequestFilteredDataQualityStandardItem -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AggregateRequestFilteredDataQualityStandardItem -> r # gmapQ :: (forall d. Data d => d -> u) -> AggregateRequestFilteredDataQualityStandardItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AggregateRequestFilteredDataQualityStandardItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AggregateRequestFilteredDataQualityStandardItem -> m AggregateRequestFilteredDataQualityStandardItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateRequestFilteredDataQualityStandardItem -> m AggregateRequestFilteredDataQualityStandardItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AggregateRequestFilteredDataQualityStandardItem -> m AggregateRequestFilteredDataQualityStandardItem #
Ord AggregateRequestFilteredDataQualityStandardItem #
Methods compare :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Ordering # (<) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool # (<=) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool # (>) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool # (>=) :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> Bool # max :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem # min :: AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem -> AggregateRequestFilteredDataQualityStandardItem #
Read AggregateRequestFilteredDataQualityStandardItem #
Methods readsPrec :: Int -> ReadS AggregateRequestFilteredDataQualityStandardItem # readList :: ReadS [AggregateRequestFilteredDataQualityStandardItem] # readPrec :: ReadPrec AggregateRequestFilteredDataQualityStandardItem # readListPrec :: ReadPrec [AggregateRequestFilteredDataQualityStandardItem] #
Show AggregateRequestFilteredDataQualityStandardItem #
Methods showsPrec :: Int -> AggregateRequestFilteredDataQualityStandardItem -> ShowS # show :: AggregateRequestFilteredDataQualityStandardItem -> String # showList :: [AggregateRequestFilteredDataQualityStandardItem] -> ShowS #
Generic AggregateRequestFilteredDataQualityStandardItem #
Associated Types type Rep AggregateRequestFilteredDataQualityStandardItem :: * -> * # Methods from :: AggregateRequestFilteredDataQualityStandardItem -> Rep AggregateRequestFilteredDataQualityStandardItem x # to :: Rep AggregateRequestFilteredDataQualityStandardItem x -> AggregateRequestFilteredDataQualityStandardItem #
Hashable AggregateRequestFilteredDataQualityStandardItem #
Methods hashWithSalt :: Int -> AggregateRequestFilteredDataQualityStandardItem -> Int # hash :: AggregateRequestFilteredDataQualityStandardItem -> Int #
ToJSON AggregateRequestFilteredDataQualityStandardItem #
Methods toJSON :: AggregateRequestFilteredDataQualityStandardItem -> Value # toEncoding :: AggregateRequestFilteredDataQualityStandardItem -> Encoding # toJSONList :: [AggregateRequestFilteredDataQualityStandardItem] -> Value # toEncodingList :: [AggregateRequestFilteredDataQualityStandardItem] -> Encoding #
FromJSON AggregateRequestFilteredDataQualityStandardItem #
Methods parseJSON :: Value -> Parser AggregateRequestFilteredDataQualityStandardItem # parseJSONList :: Value -> Parser [AggregateRequestFilteredDataQualityStandardItem] #
FromHttpApiData AggregateRequestFilteredDataQualityStandardItem #
Methods parseUrlPiece :: Text -> Either Text AggregateRequestFilteredDataQualityStandardItem # parseHeader :: ByteString -> Either Text AggregateRequestFilteredDataQualityStandardItem # parseQueryParam :: Text -> Either Text AggregateRequestFilteredDataQualityStandardItem #
ToHttpApiData AggregateRequestFilteredDataQualityStandardItem #
Methods toUrlPiece :: AggregateRequestFilteredDataQualityStandardItem -> Text # toEncodedUrlPiece :: AggregateRequestFilteredDataQualityStandardItem -> Builder # toHeader :: AggregateRequestFilteredDataQualityStandardItem -> ByteString # toQueryParam :: AggregateRequestFilteredDataQualityStandardItem -> Text #
type Rep AggregateRequestFilteredDataQualityStandardItem #
type Rep AggregateRequestFilteredDataQualityStandardItem = D1 (MetaData "AggregateRequestFilteredDataQualityStandardItem" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "DATAQUALITYBLOODGLUCOSEISO151972003" PrefixI False) U1) (C1 (MetaCons "DATAQUALITYBLOODGLUCOSEISO151972013" PrefixI False) U1)) ((:+:) (C1 (MetaCons "DataQualityBloodPressureAami" PrefixI False) U1) ((:+:) (C1 (MetaCons "DataQualityBloodPressureBhsAA" PrefixI False) U1) (C1 (MetaCons "DataQualityBloodPressureBhsAB" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "DataQualityBloodPressureBhsBA" PrefixI False) U1) (C1 (MetaCons "DataQualityBloodPressureBhsBB" PrefixI False) U1)) ((:+:) (C1 (MetaCons "DATAQUALITYBLOODPRESSUREESH2002" PrefixI False) U1) ((:+:) (C1 (MetaCons "DATAQUALITYBLOODPRESSUREESH2010" PrefixI False) U1) (C1 (MetaCons "DataQualityUnknown" PrefixI False) U1)))))

DataSource

data DataSource #

Definition of a unique source of sensor data. Data sources can expose raw data coming from hardware sensors on local or companion devices. They can also expose derived data, created by transforming or merging other data sources. Multiple data sources can exist for the same data type. Every data point inserted into or read from this service has an associated data source. The data source contains enough information to uniquely identify its data, including the hardware device and the application that collected and/or transformed the data. It also holds useful metadata, such as the hardware and application versions, and the device type. Each data source produces a unique stream of data, with a unique identifier. Not all changes to data source affect the stream identifier, so that data collected by updated versions of the same application/device can still be considered to belong to the same data stream.

See: dataSource smart constructor.

Instances

Eq DataSource #
Methods (==) :: DataSource -> DataSource -> Bool # (/=) :: DataSource -> DataSource -> Bool #
Data DataSource #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataSource -> c DataSource # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataSource # toConstr :: DataSource -> Constr # dataTypeOf :: DataSource -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataSource) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataSource) # gmapT :: (forall b. Data b => b -> b) -> DataSource -> DataSource # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataSource -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataSource -> r # gmapQ :: (forall d. Data d => d -> u) -> DataSource -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataSource -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataSource -> m DataSource # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSource -> m DataSource # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSource -> m DataSource #
Show DataSource #
Methods showsPrec :: Int -> DataSource -> ShowS # show :: DataSource -> String # showList :: [DataSource] -> ShowS #
Generic DataSource #
Associated Types type Rep DataSource :: * -> * # Methods from :: DataSource -> Rep DataSource x # to :: Rep DataSource x -> DataSource #
ToJSON DataSource #
Methods toJSON :: DataSource -> Value # toEncoding :: DataSource -> Encoding # toJSONList :: [DataSource] -> Value # toEncodingList :: [DataSource] -> Encoding #
FromJSON DataSource #
Methods parseJSON :: Value -> Parser DataSource # parseJSONList :: Value -> Parser [DataSource] #
type Rep DataSource #
type Rep DataSource = D1 (MetaData "DataSource" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "DataSource'" PrefixI True) ((::) ((::) ((::) (S1 (MetaSel (Just Symbol "_dsApplication") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Application))) (S1 (MetaSel (Just Symbol "_dsDevice") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Device)))) ((::) (S1 (MetaSel (Just Symbol "_dsDataQualityStandard") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [DataSourceDataQualityStandardItem]))) (S1 (MetaSel (Just Symbol "_dsName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))) ((::) ((::) (S1 (MetaSel (Just Symbol "_dsDataType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DataType))) (S1 (MetaSel (Just Symbol "_dsType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe DataSourceType)))) ((:*:) (S1 (MetaSel (Just Symbol "_dsDataStreamName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_dsDataStreamId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))))))

dataSource :: DataSource #

Creates a value of DataSource with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dsApplication :: Lens' DataSource (Maybe Application) #

Information about an application which feeds sensor data into the platform.

dsDevice :: Lens' DataSource (Maybe Device) #

Representation of an integrated device (such as a phone or a wearable) that can hold sensors.

dsDataQualityStandard :: Lens' DataSource [DataSourceDataQualityStandardItem] #

dsName :: Lens' DataSource (Maybe Text) #

An end-user visible name for this data source.

dsDataType :: Lens' DataSource (Maybe DataType) #

The data type defines the schema for a stream of data being collected by, inserted into, or queried from the Fitness API.

dsType :: Lens' DataSource (Maybe DataSourceType) #

A constant describing the type of this data source. Indicates whether this data source produces raw or derived data.

dsDataStreamName :: Lens' DataSource (Maybe Text) #

The stream name uniquely identifies this particular data source among other data sources of the same type from the same underlying producer. Setting the stream name is optional, but should be done whenever an application exposes two streams for the same data type, or when a device has two equivalent sensors.

dsDataStreamId :: Lens' DataSource (Maybe Text) #

A unique identifier for the data stream produced by this data source. The identifier includes: - The physical device's manufacturer, model, and serial number (UID). - The application's package name or name. Package name is used when the data source was created by an Android application. The developer project number is used when the data source was created by a REST client. - The data source's type. - The data source's stream name. Note that not all attributes of the data source are used as part of the stream identifier. In particular, the version of the hardware/the application isn't used. This allows us to preserve the same stream through version updates. This also means that two DataSource objects may represent the same data stream even if they're not equal. The exact format of the data stream ID created by an Android application is: type:dataType.name:application.packageName:device.manufacturer:device.model:device.uid:dataStreamName The exact format of the data stream ID created by a REST client is: type:dataType.name:developer project number:device.manufacturer:device.model:device.uid:dataStreamName When any of the optional fields that comprise of the data stream ID are blank, they will be omitted from the data stream ID. The minnimum viable data stream ID would be: type:dataType.name:developer project number Finally, the developer project number is obfuscated when read by any REST or Android client that did not create the data source. Only the data source creator will see the developer project number in clear and normal form.

BucketByTimePeriod

data BucketByTimePeriod #

Instances

Eq BucketByTimePeriod #
Methods (==) :: BucketByTimePeriod -> BucketByTimePeriod -> Bool # (/=) :: BucketByTimePeriod -> BucketByTimePeriod -> Bool #
Data BucketByTimePeriod #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BucketByTimePeriod -> c BucketByTimePeriod # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BucketByTimePeriod # toConstr :: BucketByTimePeriod -> Constr # dataTypeOf :: BucketByTimePeriod -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c BucketByTimePeriod) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BucketByTimePeriod) # gmapT :: (forall b. Data b => b -> b) -> BucketByTimePeriod -> BucketByTimePeriod # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTimePeriod -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTimePeriod -> r # gmapQ :: (forall d. Data d => d -> u) -> BucketByTimePeriod -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BucketByTimePeriod -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BucketByTimePeriod -> m BucketByTimePeriod # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTimePeriod -> m BucketByTimePeriod # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTimePeriod -> m BucketByTimePeriod #
Show BucketByTimePeriod #
Methods showsPrec :: Int -> BucketByTimePeriod -> ShowS # show :: BucketByTimePeriod -> String # showList :: [BucketByTimePeriod] -> ShowS #
Generic BucketByTimePeriod #
Associated Types type Rep BucketByTimePeriod :: * -> * # Methods from :: BucketByTimePeriod -> Rep BucketByTimePeriod x # to :: Rep BucketByTimePeriod x -> BucketByTimePeriod #
ToJSON BucketByTimePeriod #
Methods toJSON :: BucketByTimePeriod -> Value # toEncoding :: BucketByTimePeriod -> Encoding # toJSONList :: [BucketByTimePeriod] -> Value # toEncodingList :: [BucketByTimePeriod] -> Encoding #
FromJSON BucketByTimePeriod #
Methods parseJSON :: Value -> Parser BucketByTimePeriod # parseJSONList :: Value -> Parser [BucketByTimePeriod] #
type Rep BucketByTimePeriod #
type Rep BucketByTimePeriod = D1 (MetaData "BucketByTimePeriod" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "BucketByTimePeriod'" PrefixI True) ((::) (S1 (MetaSel (Just Symbol "_bbtpValue") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32)))) ((::) (S1 (MetaSel (Just Symbol "_bbtpType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketByTimePeriodType))) (S1 (MetaSel (Just Symbol "_bbtpTimeZoneId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))))

bucketByTimePeriod :: BucketByTimePeriod #

Creates a value of BucketByTimePeriod with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

bbtpValue :: Lens' BucketByTimePeriod (Maybe Int32) #

bbtpType :: Lens' BucketByTimePeriod (Maybe BucketByTimePeriodType) #

bbtpTimeZoneId :: Lens' BucketByTimePeriod (Maybe Text) #

org.joda.timezone.DateTimeZone

DeviceType

data DeviceType #

A constant representing the type of the device.

Constructors

ChestStrap	chestStrap
HeadMounted	headMounted
Phone	phone
Scale	scale
Tablet	tablet
Unknown	unknown
Watch	watch

Instances

Enum DeviceType #
Methods succ :: DeviceType -> DeviceType # pred :: DeviceType -> DeviceType # toEnum :: Int -> DeviceType # fromEnum :: DeviceType -> Int # enumFrom :: DeviceType -> [DeviceType] # enumFromThen :: DeviceType -> DeviceType -> [DeviceType] # enumFromTo :: DeviceType -> DeviceType -> [DeviceType] # enumFromThenTo :: DeviceType -> DeviceType -> DeviceType -> [DeviceType] #
Eq DeviceType #
Methods (==) :: DeviceType -> DeviceType -> Bool # (/=) :: DeviceType -> DeviceType -> Bool #
Data DeviceType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeviceType -> c DeviceType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DeviceType # toConstr :: DeviceType -> Constr # dataTypeOf :: DeviceType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DeviceType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeviceType) # gmapT :: (forall b. Data b => b -> b) -> DeviceType -> DeviceType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeviceType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeviceType -> r # gmapQ :: (forall d. Data d => d -> u) -> DeviceType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DeviceType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeviceType -> m DeviceType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeviceType -> m DeviceType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeviceType -> m DeviceType #
Ord DeviceType #
Methods compare :: DeviceType -> DeviceType -> Ordering # (<) :: DeviceType -> DeviceType -> Bool # (<=) :: DeviceType -> DeviceType -> Bool # (>) :: DeviceType -> DeviceType -> Bool # (>=) :: DeviceType -> DeviceType -> Bool # max :: DeviceType -> DeviceType -> DeviceType # min :: DeviceType -> DeviceType -> DeviceType #
Read DeviceType #
Methods readsPrec :: Int -> ReadS DeviceType # readList :: ReadS [DeviceType] # readPrec :: ReadPrec DeviceType # readListPrec :: ReadPrec [DeviceType] #
Show DeviceType #
Methods showsPrec :: Int -> DeviceType -> ShowS # show :: DeviceType -> String # showList :: [DeviceType] -> ShowS #
Generic DeviceType #
Associated Types type Rep DeviceType :: * -> * # Methods from :: DeviceType -> Rep DeviceType x # to :: Rep DeviceType x -> DeviceType #
Hashable DeviceType #
Methods hashWithSalt :: Int -> DeviceType -> Int # hash :: DeviceType -> Int #
ToJSON DeviceType #
Methods toJSON :: DeviceType -> Value # toEncoding :: DeviceType -> Encoding # toJSONList :: [DeviceType] -> Value # toEncodingList :: [DeviceType] -> Encoding #
FromJSON DeviceType #
Methods parseJSON :: Value -> Parser DeviceType # parseJSONList :: Value -> Parser [DeviceType] #
FromHttpApiData DeviceType #
Methods parseUrlPiece :: Text -> Either Text DeviceType # parseHeader :: ByteString -> Either Text DeviceType # parseQueryParam :: Text -> Either Text DeviceType #
ToHttpApiData DeviceType #
Methods toUrlPiece :: DeviceType -> Text # toEncodedUrlPiece :: DeviceType -> Builder # toHeader :: DeviceType -> ByteString # toQueryParam :: DeviceType -> Text #
type Rep DeviceType #
type Rep DeviceType = D1 (MetaData "DeviceType" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) ((:+:) (C1 (MetaCons "ChestStrap" PrefixI False) U1) ((:+:) (C1 (MetaCons "HeadMounted" PrefixI False) U1) (C1 (MetaCons "Phone" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "Scale" PrefixI False) U1) (C1 (MetaCons "Tablet" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Unknown" PrefixI False) U1) (C1 (MetaCons "Watch" PrefixI False) U1))))

ValueMapValEntry

data ValueMapValEntry #

Instances

Eq ValueMapValEntry #
Methods (==) :: ValueMapValEntry -> ValueMapValEntry -> Bool # (/=) :: ValueMapValEntry -> ValueMapValEntry -> Bool #
Data ValueMapValEntry #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ValueMapValEntry -> c ValueMapValEntry # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ValueMapValEntry # toConstr :: ValueMapValEntry -> Constr # dataTypeOf :: ValueMapValEntry -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ValueMapValEntry) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ValueMapValEntry) # gmapT :: (forall b. Data b => b -> b) -> ValueMapValEntry -> ValueMapValEntry # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ValueMapValEntry -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ValueMapValEntry -> r # gmapQ :: (forall d. Data d => d -> u) -> ValueMapValEntry -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ValueMapValEntry -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ValueMapValEntry -> m ValueMapValEntry # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ValueMapValEntry -> m ValueMapValEntry # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ValueMapValEntry -> m ValueMapValEntry #
Show ValueMapValEntry #
Methods showsPrec :: Int -> ValueMapValEntry -> ShowS # show :: ValueMapValEntry -> String # showList :: [ValueMapValEntry] -> ShowS #
Generic ValueMapValEntry #
Associated Types type Rep ValueMapValEntry :: * -> * # Methods from :: ValueMapValEntry -> Rep ValueMapValEntry x # to :: Rep ValueMapValEntry x -> ValueMapValEntry #
ToJSON ValueMapValEntry #
Methods toJSON :: ValueMapValEntry -> Value # toEncoding :: ValueMapValEntry -> Encoding # toJSONList :: [ValueMapValEntry] -> Value # toEncodingList :: [ValueMapValEntry] -> Encoding #
FromJSON ValueMapValEntry #
Methods parseJSON :: Value -> Parser ValueMapValEntry # parseJSONList :: Value -> Parser [ValueMapValEntry] #
type Rep ValueMapValEntry #
type Rep ValueMapValEntry = D1 (MetaData "ValueMapValEntry" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "ValueMapValEntry'" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_vmveValue") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe MapValue))) (S1 (MetaSel (Just Symbol "_vmveKey") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))))

valueMapValEntry :: ValueMapValEntry #

Creates a value of ValueMapValEntry with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

vmveValue
vmveKey

vmveValue :: Lens' ValueMapValEntry (Maybe MapValue) #

vmveKey :: Lens' ValueMapValEntry (Maybe Text) #

BucketByTime

data BucketByTime #

Instances

Eq BucketByTime #
Methods (==) :: BucketByTime -> BucketByTime -> Bool # (/=) :: BucketByTime -> BucketByTime -> Bool #
Data BucketByTime #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BucketByTime -> c BucketByTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BucketByTime # toConstr :: BucketByTime -> Constr # dataTypeOf :: BucketByTime -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c BucketByTime) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BucketByTime) # gmapT :: (forall b. Data b => b -> b) -> BucketByTime -> BucketByTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BucketByTime -> r # gmapQ :: (forall d. Data d => d -> u) -> BucketByTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BucketByTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BucketByTime -> m BucketByTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTime -> m BucketByTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BucketByTime -> m BucketByTime #
Show BucketByTime #
Methods showsPrec :: Int -> BucketByTime -> ShowS # show :: BucketByTime -> String # showList :: [BucketByTime] -> ShowS #
Generic BucketByTime #
Associated Types type Rep BucketByTime :: * -> * # Methods from :: BucketByTime -> Rep BucketByTime x # to :: Rep BucketByTime x -> BucketByTime #
ToJSON BucketByTime #
Methods toJSON :: BucketByTime -> Value # toEncoding :: BucketByTime -> Encoding # toJSONList :: [BucketByTime] -> Value # toEncodingList :: [BucketByTime] -> Encoding #
FromJSON BucketByTime #
Methods parseJSON :: Value -> Parser BucketByTime # parseJSONList :: Value -> Parser [BucketByTime] #
type Rep BucketByTime #
type Rep BucketByTime = D1 (MetaData "BucketByTime" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "BucketByTime'" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_bbtPeriod") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe BucketByTimePeriod))) (S1 (MetaSel (Just Symbol "_bbtDurationMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))))

bucketByTime :: BucketByTime #

Creates a value of BucketByTime with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

bbtPeriod
bbtDurationMillis

bbtPeriod :: Lens' BucketByTime (Maybe BucketByTimePeriod) #

bbtDurationMillis :: Lens' BucketByTime (Maybe Int64) #

Specifies that result buckets aggregate data by exactly durationMillis time frames. Time frames that contain no data will be included in the response with an empty dataset.

DataType

data DataType #

See: dataType smart constructor.

Instances

Eq DataType #
Methods (==) :: DataType -> DataType -> Bool # (/=) :: DataType -> DataType -> Bool #
Data DataType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataType -> c DataType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataType # toConstr :: DataType -> Constr # dataTypeOf :: DataType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType) # gmapT :: (forall b. Data b => b -> b) -> DataType -> DataType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataType -> r # gmapQ :: (forall d. Data d => d -> u) -> DataType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataType -> m DataType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataType -> m DataType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataType -> m DataType #
Show DataType #
Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #
Generic DataType #
Associated Types type Rep DataType :: * -> * # Methods from :: DataType -> Rep DataType x # to :: Rep DataType x -> DataType #
ToJSON DataType #
Methods toJSON :: DataType -> Value # toEncoding :: DataType -> Encoding # toJSONList :: [DataType] -> Value # toEncodingList :: [DataType] -> Encoding #
FromJSON DataType #
Methods parseJSON :: Value -> Parser DataType # parseJSONList :: Value -> Parser [DataType] #
type Rep DataType #
type Rep DataType = D1 (MetaData "DataType" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "DataType'" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_dtField") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe [DataTypeField]))) (S1 (MetaSel (Just Symbol "_dtName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text)))))

dataType :: DataType #

Creates a value of DataType with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

dtField
dtName

dtField :: Lens' DataType [DataTypeField] #

A field represents one dimension of a data type.

dtName :: Lens' DataType (Maybe Text) #

Each data type has a unique, namespaced, name. All data types in the com.google namespace are shared as part of the platform.

Session

data Session #

Sessions contain metadata, such as a user-friendly name and time interval information.

See: session smart constructor.

Instances

Eq Session #
Methods (==) :: Session -> Session -> Bool # (/=) :: Session -> Session -> Bool #
Data Session #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Session -> c Session # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Session # toConstr :: Session -> Constr # dataTypeOf :: Session -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Session) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Session) # gmapT :: (forall b. Data b => b -> b) -> Session -> Session # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Session -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Session -> r # gmapQ :: (forall d. Data d => d -> u) -> Session -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Session -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Session -> m Session # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Session -> m Session # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Session -> m Session #
Show Session #
Methods showsPrec :: Int -> Session -> ShowS # show :: Session -> String # showList :: [Session] -> ShowS #
Generic Session #
Associated Types type Rep Session :: * -> * # Methods from :: Session -> Rep Session x # to :: Rep Session x -> Session #
ToJSON Session #
Methods toJSON :: Session -> Value # toEncoding :: Session -> Encoding # toJSONList :: [Session] -> Value # toEncodingList :: [Session] -> Encoding #
FromJSON Session #
Methods parseJSON :: Value -> Parser Session # parseJSONList :: Value -> Parser [Session] #
type Rep Session #
type Rep Session = D1 (MetaData "Session" "Network.Google.Fitness.Types.Product" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) (C1 (MetaCons "Session'" PrefixI True) ((::) ((::) ((::) (S1 (MetaSel (Just Symbol "_sEndTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_sActiveTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))) ((::) (S1 (MetaSel (Just Symbol "_sApplication") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Application))) (S1 (MetaSel (Just Symbol "_sActivityType") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int32)))))) ((::) ((::) (S1 (MetaSel (Just Symbol "_sName") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "_sModifiedTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64))))) ((::) (S1 (MetaSel (Just Symbol "_sId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))) ((::) (S1 (MetaSel (Just Symbol "_sStartTimeMillis") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (Textual Int64)))) (S1 (MetaSel (Just Symbol "_sDescription") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Text))))))))

session :: Session #

Creates a value of Session with the minimum fields required to make a request.

Use one of the following lenses to modify other fields as desired:

sEndTimeMillis :: Lens' Session (Maybe Int64) #

An end time, in milliseconds since epoch, inclusive.

sActiveTimeMillis :: Lens' Session (Maybe Int64) #

Session active time. While start_time_millis and end_time_millis define the full session time, the active time can be shorter and specified by active_time_millis. If the inactive time during the session is known, it should also be inserted via a com.google.activity.segment data point with a STILL activity value

sApplication :: Lens' Session (Maybe Application) #

The application that created the session.

sActivityType :: Lens' Session (Maybe Int32) #

The type of activity this session represents.

sName :: Lens' Session (Maybe Text) #

A human readable name of the session.

sModifiedTimeMillis :: Lens' Session (Maybe Int64) #

A timestamp that indicates when the session was last modified.

sId :: Lens' Session (Maybe Text) #

A client-generated identifier that is unique across all sessions owned by this particular user.

sStartTimeMillis :: Lens' Session (Maybe Int64) #

A start time, in milliseconds since epoch, inclusive.

sDescription :: Lens' Session (Maybe Text) #

A description for this session.

DataSourceDataQualityStandardItem

data DataSourceDataQualityStandardItem #

Constructors

DSDQSIDATAQUALITYBLOODGLUCOSEISO151972003	dataQualityBloodGlucoseIso151972003
DSDQSIDATAQUALITYBLOODGLUCOSEISO151972013	dataQualityBloodGlucoseIso151972013
DSDQSIDataQualityBloodPressureAami	dataQualityBloodPressureAami
DSDQSIDataQualityBloodPressureBhsAA	dataQualityBloodPressureBhsAA
DSDQSIDataQualityBloodPressureBhsAB	dataQualityBloodPressureBhsAB
DSDQSIDataQualityBloodPressureBhsBA	dataQualityBloodPressureBhsBA
DSDQSIDataQualityBloodPressureBhsBB	dataQualityBloodPressureBhsBB
DSDQSIDATAQUALITYBLOODPRESSUREESH2002	dataQualityBloodPressureEsh2002
DSDQSIDATAQUALITYBLOODPRESSUREESH2010	dataQualityBloodPressureEsh2010
DSDQSIDataQualityUnknown	dataQualityUnknown

Instances

Enum DataSourceDataQualityStandardItem #
Methods succ :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem # pred :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem # toEnum :: Int -> DataSourceDataQualityStandardItem # fromEnum :: DataSourceDataQualityStandardItem -> Int # enumFrom :: DataSourceDataQualityStandardItem -> [DataSourceDataQualityStandardItem] # enumFromThen :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> [DataSourceDataQualityStandardItem] # enumFromTo :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> [DataSourceDataQualityStandardItem] # enumFromThenTo :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> [DataSourceDataQualityStandardItem] #
Eq DataSourceDataQualityStandardItem #
Methods (==) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool # (/=) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool #
Data DataSourceDataQualityStandardItem #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataSourceDataQualityStandardItem -> c DataSourceDataQualityStandardItem # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataSourceDataQualityStandardItem # toConstr :: DataSourceDataQualityStandardItem -> Constr # dataTypeOf :: DataSourceDataQualityStandardItem -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataSourceDataQualityStandardItem) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataSourceDataQualityStandardItem) # gmapT :: (forall b. Data b => b -> b) -> DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataSourceDataQualityStandardItem -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataSourceDataQualityStandardItem -> r # gmapQ :: (forall d. Data d => d -> u) -> DataSourceDataQualityStandardItem -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataSourceDataQualityStandardItem -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataSourceDataQualityStandardItem -> m DataSourceDataQualityStandardItem # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSourceDataQualityStandardItem -> m DataSourceDataQualityStandardItem # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataSourceDataQualityStandardItem -> m DataSourceDataQualityStandardItem #
Ord DataSourceDataQualityStandardItem #
Methods compare :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Ordering # (<) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool # (<=) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool # (>) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool # (>=) :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> Bool # max :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem # min :: DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem -> DataSourceDataQualityStandardItem #
Read DataSourceDataQualityStandardItem #
Methods readsPrec :: Int -> ReadS DataSourceDataQualityStandardItem # readList :: ReadS [DataSourceDataQualityStandardItem] # readPrec :: ReadPrec DataSourceDataQualityStandardItem # readListPrec :: ReadPrec [DataSourceDataQualityStandardItem] #
Show DataSourceDataQualityStandardItem #
Methods showsPrec :: Int -> DataSourceDataQualityStandardItem -> ShowS # show :: DataSourceDataQualityStandardItem -> String # showList :: [DataSourceDataQualityStandardItem] -> ShowS #
Generic DataSourceDataQualityStandardItem #
Associated Types type Rep DataSourceDataQualityStandardItem :: * -> * # Methods from :: DataSourceDataQualityStandardItem -> Rep DataSourceDataQualityStandardItem x # to :: Rep DataSourceDataQualityStandardItem x -> DataSourceDataQualityStandardItem #
Hashable DataSourceDataQualityStandardItem #
Methods hashWithSalt :: Int -> DataSourceDataQualityStandardItem -> Int # hash :: DataSourceDataQualityStandardItem -> Int #
ToJSON DataSourceDataQualityStandardItem #
Methods toJSON :: DataSourceDataQualityStandardItem -> Value # toEncoding :: DataSourceDataQualityStandardItem -> Encoding # toJSONList :: [DataSourceDataQualityStandardItem] -> Value # toEncodingList :: [DataSourceDataQualityStandardItem] -> Encoding #
FromJSON DataSourceDataQualityStandardItem #
Methods parseJSON :: Value -> Parser DataSourceDataQualityStandardItem # parseJSONList :: Value -> Parser [DataSourceDataQualityStandardItem] #
FromHttpApiData DataSourceDataQualityStandardItem #
Methods parseUrlPiece :: Text -> Either Text DataSourceDataQualityStandardItem # parseHeader :: ByteString -> Either Text DataSourceDataQualityStandardItem # parseQueryParam :: Text -> Either Text DataSourceDataQualityStandardItem #
ToHttpApiData DataSourceDataQualityStandardItem #
Methods toUrlPiece :: DataSourceDataQualityStandardItem -> Text # toEncodedUrlPiece :: DataSourceDataQualityStandardItem -> Builder # toHeader :: DataSourceDataQualityStandardItem -> ByteString # toQueryParam :: DataSourceDataQualityStandardItem -> Text #
type Rep DataSourceDataQualityStandardItem #
type Rep DataSourceDataQualityStandardItem = D1 (MetaData "DataSourceDataQualityStandardItem" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "DSDQSIDATAQUALITYBLOODGLUCOSEISO151972003" PrefixI False) U1) (C1 (MetaCons "DSDQSIDATAQUALITYBLOODGLUCOSEISO151972013" PrefixI False) U1)) ((:+:) (C1 (MetaCons "DSDQSIDataQualityBloodPressureAami" PrefixI False) U1) ((:+:) (C1 (MetaCons "DSDQSIDataQualityBloodPressureBhsAA" PrefixI False) U1) (C1 (MetaCons "DSDQSIDataQualityBloodPressureBhsAB" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "DSDQSIDataQualityBloodPressureBhsBA" PrefixI False) U1) (C1 (MetaCons "DSDQSIDataQualityBloodPressureBhsBB" PrefixI False) U1)) ((:+:) (C1 (MetaCons "DSDQSIDATAQUALITYBLOODPRESSUREESH2002" PrefixI False) U1) ((:+:) (C1 (MetaCons "DSDQSIDATAQUALITYBLOODPRESSUREESH2010" PrefixI False) U1) (C1 (MetaCons "DSDQSIDataQualityUnknown" PrefixI False) U1)))))

DataTypeFieldFormat

data DataTypeFieldFormat #

The different supported formats for each field in a data type.

Constructors

Blob	blob
FloatList	floatList
FloatPoint	floatPoint
Integer	integer
IntegerList	integerList
Map	map
String	string

Instances

Enum DataTypeFieldFormat #
Methods succ :: DataTypeFieldFormat -> DataTypeFieldFormat # pred :: DataTypeFieldFormat -> DataTypeFieldFormat # toEnum :: Int -> DataTypeFieldFormat # fromEnum :: DataTypeFieldFormat -> Int # enumFrom :: DataTypeFieldFormat -> [DataTypeFieldFormat] # enumFromThen :: DataTypeFieldFormat -> DataTypeFieldFormat -> [DataTypeFieldFormat] # enumFromTo :: DataTypeFieldFormat -> DataTypeFieldFormat -> [DataTypeFieldFormat] # enumFromThenTo :: DataTypeFieldFormat -> DataTypeFieldFormat -> DataTypeFieldFormat -> [DataTypeFieldFormat] #
Eq DataTypeFieldFormat #
Methods (==) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool # (/=) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool #
Data DataTypeFieldFormat #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataTypeFieldFormat -> c DataTypeFieldFormat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataTypeFieldFormat # toConstr :: DataTypeFieldFormat -> Constr # dataTypeOf :: DataTypeFieldFormat -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c DataTypeFieldFormat) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataTypeFieldFormat) # gmapT :: (forall b. Data b => b -> b) -> DataTypeFieldFormat -> DataTypeFieldFormat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataTypeFieldFormat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataTypeFieldFormat -> r # gmapQ :: (forall d. Data d => d -> u) -> DataTypeFieldFormat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataTypeFieldFormat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataTypeFieldFormat -> m DataTypeFieldFormat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataTypeFieldFormat -> m DataTypeFieldFormat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataTypeFieldFormat -> m DataTypeFieldFormat #
Ord DataTypeFieldFormat #
Methods compare :: DataTypeFieldFormat -> DataTypeFieldFormat -> Ordering # (<) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool # (<=) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool # (>) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool # (>=) :: DataTypeFieldFormat -> DataTypeFieldFormat -> Bool # max :: DataTypeFieldFormat -> DataTypeFieldFormat -> DataTypeFieldFormat # min :: DataTypeFieldFormat -> DataTypeFieldFormat -> DataTypeFieldFormat #
Read DataTypeFieldFormat #
Methods readsPrec :: Int -> ReadS DataTypeFieldFormat # readList :: ReadS [DataTypeFieldFormat] # readPrec :: ReadPrec DataTypeFieldFormat # readListPrec :: ReadPrec [DataTypeFieldFormat] #
Show DataTypeFieldFormat #
Methods showsPrec :: Int -> DataTypeFieldFormat -> ShowS # show :: DataTypeFieldFormat -> String # showList :: [DataTypeFieldFormat] -> ShowS #
Generic DataTypeFieldFormat #
Associated Types type Rep DataTypeFieldFormat :: * -> * # Methods from :: DataTypeFieldFormat -> Rep DataTypeFieldFormat x # to :: Rep DataTypeFieldFormat x -> DataTypeFieldFormat #
Hashable DataTypeFieldFormat #
Methods hashWithSalt :: Int -> DataTypeFieldFormat -> Int # hash :: DataTypeFieldFormat -> Int #
ToJSON DataTypeFieldFormat #
Methods toJSON :: DataTypeFieldFormat -> Value # toEncoding :: DataTypeFieldFormat -> Encoding # toJSONList :: [DataTypeFieldFormat] -> Value # toEncodingList :: [DataTypeFieldFormat] -> Encoding #
FromJSON DataTypeFieldFormat #
Methods parseJSON :: Value -> Parser DataTypeFieldFormat # parseJSONList :: Value -> Parser [DataTypeFieldFormat] #
FromHttpApiData DataTypeFieldFormat #
Methods parseUrlPiece :: Text -> Either Text DataTypeFieldFormat # parseHeader :: ByteString -> Either Text DataTypeFieldFormat # parseQueryParam :: Text -> Either Text DataTypeFieldFormat #
ToHttpApiData DataTypeFieldFormat #
Methods toUrlPiece :: DataTypeFieldFormat -> Text # toEncodedUrlPiece :: DataTypeFieldFormat -> Builder # toHeader :: DataTypeFieldFormat -> ByteString # toQueryParam :: DataTypeFieldFormat -> Text #
type Rep DataTypeFieldFormat #
type Rep DataTypeFieldFormat = D1 (MetaData "DataTypeFieldFormat" "Network.Google.Fitness.Types.Sum" "gogol-fitness-0.3.0-JmHHvYyhBJE5MQYvnGvwrt" False) ((:+:) ((:+:) (C1 (MetaCons "Blob" PrefixI False) U1) ((:+:) (C1 (MetaCons "FloatList" PrefixI False) U1) (C1 (MetaCons "FloatPoint" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "Integer" PrefixI False) U1) (C1 (MetaCons "IntegerList" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Map" PrefixI False) U1) (C1 (MetaCons "String" PrefixI False) U1))))