lemboy-google-api-client 0.9.26

data/generated/google/apis/fitness_v1.rb

@@ -0,0 +1,85 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'google/apis/fitness_v1/service.rb'
+require 'google/apis/fitness_v1/classes.rb'
+require 'google/apis/fitness_v1/representations.rb'
+
+module Google
+  module Apis
+    # Fitness
+    #
+    # Stores and accesses user data in the fitness store from apps on any platform.
+    #
+    # @see https://developers.google.com/fit/rest/
+    module FitnessV1
+      VERSION = 'V1'
+      REVISION = '20161128'
+
+      # View your activity information in Google Fit
+      AUTH_FITNESS_ACTIVITY_READ = 'https://www.googleapis.com/auth/fitness.activity.read'
+
+      # View and store your activity information in Google Fit
+      AUTH_FITNESS_ACTIVITY_WRITE = 'https://www.googleapis.com/auth/fitness.activity.write'
+
+      # View blood glucose data in Google Fit
+      AUTH_FITNESS_BLOOD_GLUCOSE_READ = 'https://www.googleapis.com/auth/fitness.blood_glucose.read'
+
+      # View and store blood glucose data in Google Fit
+      AUTH_FITNESS_BLOOD_GLUCOSE_WRITE = 'https://www.googleapis.com/auth/fitness.blood_glucose.write'
+
+      # View blood pressure data in Google Fit
+      AUTH_FITNESS_BLOOD_PRESSURE_READ = 'https://www.googleapis.com/auth/fitness.blood_pressure.read'
+
+      # View and store blood pressure data in Google Fit
+      AUTH_FITNESS_BLOOD_PRESSURE_WRITE = 'https://www.googleapis.com/auth/fitness.blood_pressure.write'
+
+      # View body sensor information in Google Fit
+      AUTH_FITNESS_BODY_READ = 'https://www.googleapis.com/auth/fitness.body.read'
+
+      # View and store body sensor data in Google Fit
+      AUTH_FITNESS_BODY_WRITE = 'https://www.googleapis.com/auth/fitness.body.write'
+
+      # View body temperature data in Google Fit
+      AUTH_FITNESS_BODY_TEMPERATURE_READ = 'https://www.googleapis.com/auth/fitness.body_temperature.read'
+
+      # View and store body temperature data in Google Fit
+      AUTH_FITNESS_BODY_TEMPERATURE_WRITE = 'https://www.googleapis.com/auth/fitness.body_temperature.write'
+
+      # View your stored location data in Google Fit
+      AUTH_FITNESS_LOCATION_READ = 'https://www.googleapis.com/auth/fitness.location.read'
+
+      # View and store your location data in Google Fit
+      AUTH_FITNESS_LOCATION_WRITE = 'https://www.googleapis.com/auth/fitness.location.write'
+
+      # View nutrition information in Google Fit
+      AUTH_FITNESS_NUTRITION_READ = 'https://www.googleapis.com/auth/fitness.nutrition.read'
+
+      # View and store nutrition information in Google Fit
+      AUTH_FITNESS_NUTRITION_WRITE = 'https://www.googleapis.com/auth/fitness.nutrition.write'
+
+      # View oxygen saturation data in Google Fit
+      AUTH_FITNESS_OXYGEN_SATURATION_READ = 'https://www.googleapis.com/auth/fitness.oxygen_saturation.read'
+
+      # View and store oxygen saturation data in Google Fit
+      AUTH_FITNESS_OXYGEN_SATURATION_WRITE = 'https://www.googleapis.com/auth/fitness.oxygen_saturation.write'
+
+      # View reproductive health data in Google Fit
+      AUTH_FITNESS_REPRODUCTIVE_HEALTH_READ = 'https://www.googleapis.com/auth/fitness.reproductive_health.read'
+
+      # View and store reproductive health data in Google Fit
+      AUTH_FITNESS_REPRODUCTIVE_HEALTH_WRITE = 'https://www.googleapis.com/auth/fitness.reproductive_health.write'
+    end
+  end
+end

data/generated/google/apis/fitness_v1/classes.rb

@@ -0,0 +1,943 @@
+# Copyright 2015 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'date'
+require 'google/apis/core/base_service'
+require 'google/apis/core/json_representation'
+require 'google/apis/core/hashable'
+require 'google/apis/errors'
+
+module Google
+  module Apis
+    module FitnessV1
+      
+      # 
+      class AggregateBucket
+        include Google::Apis::Core::Hashable
+      
+        # Available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT
+        # Corresponds to the JSON property `activity`
+        # @return [Fixnum]
+        attr_accessor :activity
+      
+        # There will be one dataset per AggregateBy in the request.
+        # Corresponds to the JSON property `dataset`
+        # @return [Array<Google::Apis::FitnessV1::Dataset>]
+        attr_accessor :dataset
+      
+        # The end time for the aggregated data, in milliseconds since epoch, inclusive.
+        # Corresponds to the JSON property `endTimeMillis`
+        # @return [String]
+        attr_accessor :end_time_millis
+      
+        # Sessions contain metadata, such as a user-friendly name and time interval
+        # information.
+        # Corresponds to the JSON property `session`
+        # @return [Google::Apis::FitnessV1::Session]
+        attr_accessor :session
+      
+        # The start time for the aggregated data, in milliseconds since epoch, inclusive.
+        # Corresponds to the JSON property `startTimeMillis`
+        # @return [String]
+        attr_accessor :start_time_millis
+      
+        # The type of a bucket signifies how the data aggregation is performed in the
+        # bucket.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @activity = args[:activity] if args.key?(:activity)
+          @dataset = args[:dataset] if args.key?(:dataset)
+          @end_time_millis = args[:end_time_millis] if args.key?(:end_time_millis)
+          @session = args[:session] if args.key?(:session)
+          @start_time_millis = args[:start_time_millis] if args.key?(:start_time_millis)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # The specification of which data to aggregate.
+      class AggregateBy
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `dataSourceId`
+        # @return [String]
+        attr_accessor :data_source_id
+      
+        # 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
+        # Corresponds to the JSON property `dataTypeName`
+        # @return [String]
+        attr_accessor :data_type_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data_source_id = args[:data_source_id] if args.key?(:data_source_id)
+          @data_type_name = args[:data_type_name] if args.key?(:data_type_name)
+        end
+      end
+      
+      # Next id: 10
+      class AggregateRequest
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `aggregateBy`
+        # @return [Array<Google::Apis::FitnessV1::AggregateBy>]
+        attr_accessor :aggregate_by
+      
+        # 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.
+        # Corresponds to the JSON property `bucketByActivitySegment`
+        # @return [Google::Apis::FitnessV1::BucketByActivity]
+        attr_accessor :bucket_by_activity_segment
+      
+        # 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.
+        # Corresponds to the JSON property `bucketByActivityType`
+        # @return [Google::Apis::FitnessV1::BucketByActivity]
+        attr_accessor :bucket_by_activity_type
+      
+        # 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.
+        # Corresponds to the JSON property `bucketBySession`
+        # @return [Google::Apis::FitnessV1::BucketBySession]
+        attr_accessor :bucket_by_session
+      
+        # Specifies that data be aggregated by a single time interval. Mutually
+        # exclusive of other bucketing specifications.
+        # Corresponds to the JSON property `bucketByTime`
+        # @return [Google::Apis::FitnessV1::BucketByTime]
+        attr_accessor :bucket_by_time
+      
+        # 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.
+        # Corresponds to the JSON property `endTimeMillis`
+        # @return [String]
+        attr_accessor :end_time_millis
+      
+        # 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.
+        # Corresponds to the JSON property `filteredDataQualityStandard`
+        # @return [Array<String>]
+        attr_accessor :filtered_data_quality_standard
+      
+        # 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.
+        # Corresponds to the JSON property `startTimeMillis`
+        # @return [String]
+        attr_accessor :start_time_millis
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @aggregate_by = args[:aggregate_by] if args.key?(:aggregate_by)
+          @bucket_by_activity_segment = args[:bucket_by_activity_segment] if args.key?(:bucket_by_activity_segment)
+          @bucket_by_activity_type = args[:bucket_by_activity_type] if args.key?(:bucket_by_activity_type)
+          @bucket_by_session = args[:bucket_by_session] if args.key?(:bucket_by_session)
+          @bucket_by_time = args[:bucket_by_time] if args.key?(:bucket_by_time)
+          @end_time_millis = args[:end_time_millis] if args.key?(:end_time_millis)
+          @filtered_data_quality_standard = args[:filtered_data_quality_standard] if args.key?(:filtered_data_quality_standard)
+          @start_time_millis = args[:start_time_millis] if args.key?(:start_time_millis)
+        end
+      end
+      
+      # 
+      class AggregateResponse
+        include Google::Apis::Core::Hashable
+      
+        # A list of buckets containing the aggregated data.
+        # Corresponds to the JSON property `bucket`
+        # @return [Array<Google::Apis::FitnessV1::AggregateBucket>]
+        attr_accessor :bucket
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @bucket = args[:bucket] if args.key?(:bucket)
+        end
+      end
+      
+      # 
+      class Application
+        include Google::Apis::Core::Hashable
+      
+        # An optional URI that can be used to link back to the application.
+        # Corresponds to the JSON property `detailsUrl`
+        # @return [String]
+        attr_accessor :details_url
+      
+        # 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.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # 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.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        # Version of the application. You should update this field whenever the
+        # application changes in a way that affects the computation of the data.
+        # Corresponds to the JSON property `version`
+        # @return [String]
+        attr_accessor :version
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @details_url = args[:details_url] if args.key?(:details_url)
+          @name = args[:name] if args.key?(:name)
+          @package_name = args[:package_name] if args.key?(:package_name)
+          @version = args[:version] if args.key?(:version)
+        end
+      end
+      
+      # 
+      class BucketByActivity
+        include Google::Apis::Core::Hashable
+      
+        # The default activity stream will be used if a specific activityDataSourceId is
+        # not specified.
+        # Corresponds to the JSON property `activityDataSourceId`
+        # @return [String]
+        attr_accessor :activity_data_source_id
+      
+        # Specifies that only activity segments of duration longer than
+        # minDurationMillis are considered and used as a container for aggregated data.
+        # Corresponds to the JSON property `minDurationMillis`
+        # @return [String]
+        attr_accessor :min_duration_millis
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @activity_data_source_id = args[:activity_data_source_id] if args.key?(:activity_data_source_id)
+          @min_duration_millis = args[:min_duration_millis] if args.key?(:min_duration_millis)
+        end
+      end
+      
+      # 
+      class BucketBySession
+        include Google::Apis::Core::Hashable
+      
+        # Specifies that only sessions of duration longer than minDurationMillis are
+        # considered and used as a container for aggregated data.
+        # Corresponds to the JSON property `minDurationMillis`
+        # @return [String]
+        attr_accessor :min_duration_millis
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @min_duration_millis = args[:min_duration_millis] if args.key?(:min_duration_millis)
+        end
+      end
+      
+      # 
+      class BucketByTime
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `durationMillis`
+        # @return [String]
+        attr_accessor :duration_millis
+      
+        # 
+        # Corresponds to the JSON property `period`
+        # @return [Google::Apis::FitnessV1::BucketByTimePeriod]
+        attr_accessor :period
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @duration_millis = args[:duration_millis] if args.key?(:duration_millis)
+          @period = args[:period] if args.key?(:period)
+        end
+      end
+      
+      # 
+      class BucketByTimePeriod
+        include Google::Apis::Core::Hashable
+      
+        # org.joda.timezone.DateTimeZone
+        # Corresponds to the JSON property `timeZoneId`
+        # @return [String]
+        attr_accessor :time_zone_id
+      
+        # 
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # 
+        # Corresponds to the JSON property `value`
+        # @return [Fixnum]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @time_zone_id = args[:time_zone_id] if args.key?(:time_zone_id)
+          @type = args[:type] if args.key?(:type)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # 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.
+      class DataPoint
+        include Google::Apis::Core::Hashable
+      
+        # Used for version checking during transformation; that is, a datapoint can only
+        # replace another datapoint that has an older computation time stamp.
+        # Corresponds to the JSON property `computationTimeMillis`
+        # @return [String]
+        attr_accessor :computation_time_millis
+      
+        # The data type defining the format of the values in this data point.
+        # Corresponds to the JSON property `dataTypeName`
+        # @return [String]
+        attr_accessor :data_type_name
+      
+        # The end time of the interval represented by this data point, in nanoseconds
+        # since epoch.
+        # Corresponds to the JSON property `endTimeNanos`
+        # @return [String]
+        attr_accessor :end_time_nanos
+      
+        # 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.
+        # Corresponds to the JSON property `modifiedTimeMillis`
+        # @return [String]
+        attr_accessor :modified_time_millis
+      
+        # 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.
+        # Corresponds to the JSON property `originDataSourceId`
+        # @return [String]
+        attr_accessor :origin_data_source_id
+      
+        # The raw timestamp from the original SensorEvent.
+        # Corresponds to the JSON property `rawTimestampNanos`
+        # @return [String]
+        attr_accessor :raw_timestamp_nanos
+      
+        # The start time of the interval represented by this data point, in nanoseconds
+        # since epoch.
+        # Corresponds to the JSON property `startTimeNanos`
+        # @return [String]
+        attr_accessor :start_time_nanos
+      
+        # 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.
+        # Corresponds to the JSON property `value`
+        # @return [Array<Google::Apis::FitnessV1::Value>]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @computation_time_millis = args[:computation_time_millis] if args.key?(:computation_time_millis)
+          @data_type_name = args[:data_type_name] if args.key?(:data_type_name)
+          @end_time_nanos = args[:end_time_nanos] if args.key?(:end_time_nanos)
+          @modified_time_millis = args[:modified_time_millis] if args.key?(:modified_time_millis)
+          @origin_data_source_id = args[:origin_data_source_id] if args.key?(:origin_data_source_id)
+          @raw_timestamp_nanos = args[:raw_timestamp_nanos] if args.key?(:raw_timestamp_nanos)
+          @start_time_nanos = args[:start_time_nanos] if args.key?(:start_time_nanos)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # 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.
+      class DataSource
+        include Google::Apis::Core::Hashable
+      
+        # 
+        # Corresponds to the JSON property `application`
+        # @return [Google::Apis::FitnessV1::Application]
+        attr_accessor :application
+      
+        # 
+        # Corresponds to the JSON property `dataQualityStandard`
+        # @return [Array<String>]
+        attr_accessor :data_quality_standard
+      
+        # 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.
+        # Corresponds to the JSON property `dataStreamId`
+        # @return [String]
+        attr_accessor :data_stream_id
+      
+        # 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.
+        # Corresponds to the JSON property `dataStreamName`
+        # @return [String]
+        attr_accessor :data_stream_name
+      
+        # 
+        # Corresponds to the JSON property `dataType`
+        # @return [Google::Apis::FitnessV1::DataType]
+        attr_accessor :data_type
+      
+        # 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.
+        # Corresponds to the JSON property `device`
+        # @return [Google::Apis::FitnessV1::Device]
+        attr_accessor :device
+      
+        # An end-user visible name for this data source.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A constant describing the type of this data source. Indicates whether this
+        # data source produces raw or derived data.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @application = args[:application] if args.key?(:application)
+          @data_quality_standard = args[:data_quality_standard] if args.key?(:data_quality_standard)
+          @data_stream_id = args[:data_stream_id] if args.key?(:data_stream_id)
+          @data_stream_name = args[:data_stream_name] if args.key?(:data_stream_name)
+          @data_type = args[:data_type] if args.key?(:data_type)
+          @device = args[:device] if args.key?(:device)
+          @name = args[:name] if args.key?(:name)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # 
+      class DataType
+        include Google::Apis::Core::Hashable
+      
+        # A field represents one dimension of a data type.
+        # Corresponds to the JSON property `field`
+        # @return [Array<Google::Apis::FitnessV1::DataTypeField>]
+        attr_accessor :field
+      
+        # Each data type has a unique, namespaced, name. All data types in the com.
+        # google namespace are shared as part of the platform.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @field = args[:field] if args.key?(:field)
+          @name = args[:name] if args.key?(:name)
+        end
+      end
+      
+      # 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.
+      class DataTypeField
+        include Google::Apis::Core::Hashable
+      
+        # The different supported formats for each field in a data type.
+        # Corresponds to the JSON property `format`
+        # @return [String]
+        attr_accessor :format
+      
+        # 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.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # 
+        # Corresponds to the JSON property `optional`
+        # @return [Boolean]
+        attr_accessor :optional
+        alias_method :optional?, :optional
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @format = args[:format] if args.key?(:format)
+          @name = args[:name] if args.key?(:name)
+          @optional = args[:optional] if args.key?(:optional)
+        end
+      end
+      
+      # 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.
+      class Dataset
+        include Google::Apis::Core::Hashable
+      
+        # The data stream ID of the data source that created the points in this dataset.
+        # Corresponds to the JSON property `dataSourceId`
+        # @return [String]
+        attr_accessor :data_source_id
+      
+        # 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.
+        # Corresponds to the JSON property `maxEndTimeNs`
+        # @return [String]
+        attr_accessor :max_end_time_ns
+      
+        # 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.
+        # Corresponds to the JSON property `minStartTimeNs`
+        # @return [String]
+        attr_accessor :min_start_time_ns
+      
+        # 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.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # 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.
+        # Corresponds to the JSON property `point`
+        # @return [Array<Google::Apis::FitnessV1::DataPoint>]
+        attr_accessor :point
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data_source_id = args[:data_source_id] if args.key?(:data_source_id)
+          @max_end_time_ns = args[:max_end_time_ns] if args.key?(:max_end_time_ns)
+          @min_start_time_ns = args[:min_start_time_ns] if args.key?(:min_start_time_ns)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @point = args[:point] if args.key?(:point)
+        end
+      end
+      
+      # 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.
+      class Device
+        include Google::Apis::Core::Hashable
+      
+        # Manufacturer of the product/hardware.
+        # Corresponds to the JSON property `manufacturer`
+        # @return [String]
+        attr_accessor :manufacturer
+      
+        # End-user visible model name for the device.
+        # Corresponds to the JSON property `model`
+        # @return [String]
+        attr_accessor :model
+      
+        # A constant representing the type of the device.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # 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.
+        # Corresponds to the JSON property `uid`
+        # @return [String]
+        attr_accessor :uid
+      
+        # Version string for the device hardware/software.
+        # Corresponds to the JSON property `version`
+        # @return [String]
+        attr_accessor :version
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @manufacturer = args[:manufacturer] if args.key?(:manufacturer)
+          @model = args[:model] if args.key?(:model)
+          @type = args[:type] if args.key?(:type)
+          @uid = args[:uid] if args.key?(:uid)
+          @version = args[:version] if args.key?(:version)
+        end
+      end
+      
+      # 
+      class ListDataSourcesResponse
+        include Google::Apis::Core::Hashable
+      
+        # A previously created data source.
+        # Corresponds to the JSON property `dataSource`
+        # @return [Array<Google::Apis::FitnessV1::DataSource>]
+        attr_accessor :data_source
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @data_source = args[:data_source] if args.key?(:data_source)
+        end
+      end
+      
+      # 
+      class ListSessionsResponse
+        include Google::Apis::Core::Hashable
+      
+        # 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.
+        # Corresponds to the JSON property `deletedSession`
+        # @return [Array<Google::Apis::FitnessV1::Session>]
+        attr_accessor :deleted_session
+      
+        # Flag to indicate server has more data to transfer
+        # Corresponds to the JSON property `hasMoreData`
+        # @return [Boolean]
+        attr_accessor :has_more_data
+        alias_method :has_more_data?, :has_more_data
+      
+        # 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.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # Sessions with an end time that is between startTime and endTime of the request.
+        # Corresponds to the JSON property `session`
+        # @return [Array<Google::Apis::FitnessV1::Session>]
+        attr_accessor :session
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @deleted_session = args[:deleted_session] if args.key?(:deleted_session)
+          @has_more_data = args[:has_more_data] if args.key?(:has_more_data)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @session = args[:session] if args.key?(:session)
+        end
+      end
+      
+      # 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.
+      class MapValue
+        include Google::Apis::Core::Hashable
+      
+        # Floating point value.
+        # Corresponds to the JSON property `fpVal`
+        # @return [Float]
+        attr_accessor :fp_val
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @fp_val = args[:fp_val] if args.key?(:fp_val)
+        end
+      end
+      
+      # Sessions contain metadata, such as a user-friendly name and time interval
+      # information.
+      class Session
+        include Google::Apis::Core::Hashable
+      
+        # 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
+        # Corresponds to the JSON property `activeTimeMillis`
+        # @return [String]
+        attr_accessor :active_time_millis
+      
+        # The type of activity this session represents.
+        # Corresponds to the JSON property `activityType`
+        # @return [Fixnum]
+        attr_accessor :activity_type
+      
+        # 
+        # Corresponds to the JSON property `application`
+        # @return [Google::Apis::FitnessV1::Application]
+        attr_accessor :application
+      
+        # A description for this session.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # An end time, in milliseconds since epoch, inclusive.
+        # Corresponds to the JSON property `endTimeMillis`
+        # @return [String]
+        attr_accessor :end_time_millis
+      
+        # A client-generated identifier that is unique across all sessions owned by this
+        # particular user.
+        # Corresponds to the JSON property `id`
+        # @return [String]
+        attr_accessor :id
+      
+        # A timestamp that indicates when the session was last modified.
+        # Corresponds to the JSON property `modifiedTimeMillis`
+        # @return [String]
+        attr_accessor :modified_time_millis
+      
+        # A human readable name of the session.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A start time, in milliseconds since epoch, inclusive.
+        # Corresponds to the JSON property `startTimeMillis`
+        # @return [String]
+        attr_accessor :start_time_millis
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @active_time_millis = args[:active_time_millis] if args.key?(:active_time_millis)
+          @activity_type = args[:activity_type] if args.key?(:activity_type)
+          @application = args[:application] if args.key?(:application)
+          @description = args[:description] if args.key?(:description)
+          @end_time_millis = args[:end_time_millis] if args.key?(:end_time_millis)
+          @id = args[:id] if args.key?(:id)
+          @modified_time_millis = args[:modified_time_millis] if args.key?(:modified_time_millis)
+          @name = args[:name] if args.key?(:name)
+          @start_time_millis = args[:start_time_millis] if args.key?(:start_time_millis)
+        end
+      end
+      
+      # 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
+      class Value
+        include Google::Apis::Core::Hashable
+      
+        # Floating point value. When this is set, other values must not be set.
+        # Corresponds to the JSON property `fpVal`
+        # @return [Float]
+        attr_accessor :fp_val
+      
+        # Integer value. When this is set, other values must not be set.
+        # Corresponds to the JSON property `intVal`
+        # @return [Fixnum]
+        attr_accessor :int_val
+      
+        # 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.
+        # Corresponds to the JSON property `mapVal`
+        # @return [Array<Google::Apis::FitnessV1::ValueMapValEntry>]
+        attr_accessor :map_val
+      
+        # 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.
+        # Corresponds to the JSON property `stringVal`
+        # @return [String]
+        attr_accessor :string_val
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @fp_val = args[:fp_val] if args.key?(:fp_val)
+          @int_val = args[:int_val] if args.key?(:int_val)
+          @map_val = args[:map_val] if args.key?(:map_val)
+          @string_val = args[:string_val] if args.key?(:string_val)
+        end
+      end
+      
+      # 
+      class ValueMapValEntry
+        include Google::Apis::Core::Hashable
+      
+        # 
+        # Corresponds to the JSON property `key`
+        # @return [String]
+        attr_accessor :key
+      
+        # 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.
+        # Corresponds to the JSON property `value`
+        # @return [Google::Apis::FitnessV1::MapValue]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @key = args[:key] if args.key?(:key)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+    end
+  end
+end