google-apis-fitness_v1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6f6edb80909963abb7517cfa36c53a1d6688881d03411fc43ea825dacfb9560
+  data.tar.gz: 1c633dacca1b53e313886fbc37799221f94e418ba3cd090847291b2aaeeec575
+SHA512:
+  metadata.gz: 8571a3c0c56c0bf4d57ddb17489d5bc6d3f707a9abf39ad4100bd44d23cd31f1566f687f1e0e6caae682a3ef578382b34e86bd1e913d22a7bdcaac8682030318
+  data.tar.gz: 69e53bc5e01e3f85ba681b19f4666f0faabbf0761e7909497bf0062663f39cfabbd1413514c6ba4bedcf46df978cc164c219780b3037f65ed7afe2ac67ef0cb2

data/.yardopts

@@ -0,0 +1,13 @@
+--hide-void-return
+--no-private
+--verbose
+--title=google-apis-fitness_v1
+--markup-provider=redcarpet
+--markup=markdown
+--main OVERVIEW.md
+lib/google/apis/fitness_v1/*.rb
+lib/google/apis/fitness_v1.rb
+-
+OVERVIEW.md
+CHANGELOG.md
+LICENSE.md

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Release history for google-apis-fitness_v1
+
+### v0.1.0 (2021-01-07)
+
+* Regenerated using generator version 0.1.1
+* Regenerated from discovery document revision 20201012
+

data/LICENSE.md

@@ -0,0 +1,202 @@
+
+                                  Apache License
+                            Version 2.0, January 2004
+                         http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+       "License" shall mean the terms and conditions for use, reproduction,
+       and distribution as defined by Sections 1 through 9 of this document.
+
+       "Licensor" shall mean the copyright owner or entity authorized by
+       the copyright owner that is granting the License.
+
+       "Legal Entity" shall mean the union of the acting entity and all
+       other entities that control, are controlled by, or are under common
+       control with that entity. For the purposes of this definition,
+       "control" means (i) the power, direct or indirect, to cause the
+       direction or management of such entity, whether by contract or
+       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+       outstanding shares, or (iii) beneficial ownership of such entity.
+
+       "You" (or "Your") shall mean an individual or Legal Entity
+       exercising permissions granted by this License.
+
+       "Source" form shall mean the preferred form for making modifications,
+       including but not limited to software source code, documentation
+       source, and configuration files.
+
+       "Object" form shall mean any form resulting from mechanical
+       transformation or translation of a Source form, including but
+       not limited to compiled object code, generated documentation,
+       and conversions to other media types.
+
+       "Work" shall mean the work of authorship, whether in Source or
+       Object form, made available under the License, as indicated by a
+       copyright notice that is included in or attached to the work
+       (an example is provided in the Appendix below).
+
+       "Derivative Works" shall mean any work, whether in Source or Object
+       form, that is based on (or derived from) the Work and for which the
+       editorial revisions, annotations, elaborations, or other modifications
+       represent, as a whole, an original work of authorship. For the purposes
+       of this License, Derivative Works shall not include works that remain
+       separable from, or merely link (or bind by name) to the interfaces of,
+       the Work and Derivative Works thereof.
+
+       "Contribution" shall mean any work of authorship, including
+       the original version of the Work and any modifications or additions
+       to that Work or Derivative Works thereof, that is intentionally
+       submitted to Licensor for inclusion in the Work by the copyright owner
+       or by an individual or Legal Entity authorized to submit on behalf of
+       the copyright owner. For the purposes of this definition, "submitted"
+       means any form of electronic, verbal, or written communication sent
+       to the Licensor or its representatives, including but not limited to
+       communication on electronic mailing lists, source code control systems,
+       and issue tracking systems that are managed by, or on behalf of, the
+       Licensor for the purpose of discussing and improving the Work, but
+       excluding communication that is conspicuously marked or otherwise
+       designated in writing by the copyright owner as "Not a Contribution."
+
+       "Contributor" shall mean Licensor and any individual or Legal Entity
+       on behalf of whom a Contribution has been received by Licensor and
+       subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       copyright license to reproduce, prepare Derivative Works of,
+       publicly display, publicly perform, sublicense, and distribute the
+       Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+       this License, each Contributor hereby grants to You a perpetual,
+       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+       (except as stated in this section) patent license to make, have made,
+       use, offer to sell, sell, import, and otherwise transfer the Work,
+       where such license applies only to those patent claims licensable
+       by such Contributor that are necessarily infringed by their
+       Contribution(s) alone or by combination of their Contribution(s)
+       with the Work to which such Contribution(s) was submitted. If You
+       institute patent litigation against any entity (including a
+       cross-claim or counterclaim in a lawsuit) alleging that the Work
+       or a Contribution incorporated within the Work constitutes direct
+       or contributory patent infringement, then any patent licenses
+       granted to You under this License for that Work shall terminate
+       as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+       Work or Derivative Works thereof in any medium, with or without
+       modifications, and in Source or Object form, provided that You
+       meet the following conditions:
+
+       (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+       (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+       (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+       (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+       You may add Your own copyright statement to Your modifications and
+       may provide additional or different license terms and conditions
+       for use, reproduction, or distribution of Your modifications, or
+       for any such Derivative Works as a whole, provided Your use,
+       reproduction, and distribution of the Work otherwise complies with
+       the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+       any Contribution intentionally submitted for inclusion in the Work
+       by You to the Licensor shall be under the terms and conditions of
+       this License, without any additional terms or conditions.
+       Notwithstanding the above, nothing herein shall supersede or modify
+       the terms of any separate license agreement you may have executed
+       with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+       names, trademarks, service marks, or product names of the Licensor,
+       except as required for reasonable and customary use in describing the
+       origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+       agreed to in writing, Licensor provides the Work (and each
+       Contributor provides its Contributions) on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+       implied, including, without limitation, any warranties or conditions
+       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+       PARTICULAR PURPOSE. You are solely responsible for determining the
+       appropriateness of using or redistributing the Work and assume any
+       risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+       whether in tort (including negligence), contract, or otherwise,
+       unless required by applicable law (such as deliberate and grossly
+       negligent acts) or agreed to in writing, shall any Contributor be
+       liable to You for damages, including any direct, indirect, special,
+       incidental, or consequential damages of any character arising as a
+       result of this License or out of the use or inability to use the
+       Work (including but not limited to damages for loss of goodwill,
+       work stoppage, computer failure or malfunction, or any and all
+       other commercial damages or losses), even if such Contributor
+       has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+       the Work or Derivative Works thereof, You may choose to offer,
+       and charge a fee for, acceptance of support, warranty, indemnity,
+       or other liability obligations and/or rights consistent with this
+       License. However, in accepting such obligations, You may act only
+       on Your own behalf and on Your sole responsibility, not on behalf
+       of any other Contributor, and only if You agree to indemnify,
+       defend, and hold each Contributor harmless for any liability
+       incurred by, or claims asserted against, such Contributor by reason
+       of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+       To apply the Apache License to your work, attach the following
+       boilerplate notice, with the fields enclosed by brackets "[]"
+       replaced with your own identifying information. (Don't include
+       the brackets!)  The text should be enclosed in the appropriate
+       comment syntax for the file format. We also recommend that a
+       file or class name and description of purpose be included on the
+       same "printed page" as the copyright notice for easier
+       identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    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.

data/OVERVIEW.md

@@ -0,0 +1,96 @@
+# Simple REST client for version V1 of the Fitness API
+
+This is a simple client library for version V1 of the Fitness API. It provides:
+
+* A client object that connects to the HTTP/JSON REST endpoint for the service.
+* Ruby objects for data structures related to the service.
+* Integration with the googleauth gem for authentication using OAuth, API keys, and service accounts.
+* Control of retry, pagination, and timeouts.
+
+Note that although this client library is supported and will continue to be updated to track changes to the service, it is otherwise considered complete and not under active development. Many Google services, especially Google Cloud Platform services, may provide a more modern client that is under more active development and improvement. See the section below titled *Which client should I use?* for more information.
+
+## Getting started
+
+### Before you begin
+
+There are a few setup steps you need to complete before you can use this library:
+
+ 1. If you don't already have a Google account, [sign up](https://www.google.com/accounts).
+ 2. If you have never created a Google APIs Console project, read about [Managing Projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects) and create a project in the [Google API Console](https://console.cloud.google.com/).
+ 3. Most APIs need to be enabled for your project. [Enable it](https://console.cloud.google.com/apis/library/fitness.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-fitness_v1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-fitness_v1
+```
+
+### Creating a client object
+
+Once the gem is installed, you can load the client code and instantiate a client.
+
+```ruby
+# Load the client
+require "google/apis/fitness_v1"
+
+# Create a client object
+client = Google::Apis::FitnessV1::FitnessService.new
+
+# Authenticate calls
+client.authentication = # ... use the googleauth gem to create credentials
+```
+
+See the class reference docs for information on the methods you can call from a client.
+
+## Documentation
+
+More detailed descriptions of the Google simple REST clients are available in two documents.
+
+ *  The [Usage Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/usage-guide.md) discusses how to make API calls, how to use the provided data structures, and how to work the various features of the client library, including media upload and download, error handling, retries, pagination, and logging.
+ *  The [Auth Guide](https://github.com/googleapis/google-api-ruby-client/blob/master/docs/auth-guide.md) discusses authentication in the client libraries, including API keys, OAuth 2.0, service accounts, and environment variables.
+
+(Note: the above documents are written for the simple REST clients in general, and their examples may not reflect the Fitness service in particular.)
+
+For reference information on specific calls in the Fitness API, see the {Google::Apis::FitnessV1::FitnessService class reference docs}.
+
+## Which client should I use?
+
+Google provides two types of Ruby API client libraries: **simple REST clients** and **modern clients**.
+
+This library, `google-apis-fitness_v1`, is a simple REST client. You can identify these clients by their gem names, which are always in the form `google-apis-<servicename>_<serviceversion>`. The simple REST clients connect to HTTP/JSON REST endpoints and are automatically generated from service discovery documents. They support most API functionality, but their class interfaces are sometimes awkward.
+
+Modern clients are produced by a modern code generator, sometimes combined with hand-crafted functionality. Most modern clients connect to high-performance gRPC endpoints, although a few are backed by REST services. Modern clients are available for many Google services, especially Google Cloud Platform services, but do not yet support all the services covered by the simple clients.
+
+Gem names for modern clients are often of the form `google-cloud-<service_name>`. (For example, [google-cloud-pubsub](https://rubygems.org/gems/google-cloud-pubsub).) Note that most modern clients also have corresponding "versioned" gems with names like `google-cloud-<service_name>-<version>`. (For example, [google-cloud-pubsub-v1](https://rubygems.org/gems/google-cloud-pubsub-v1).) The "versioned" gems can be used directly, but often provide lower-level interfaces. In most cases, the main gem is recommended.
+
+**For most users, we recommend the modern client, if one is available.** Compared with simple clients, modern clients are generally much easier to use and more Ruby-like, support more advanced features such as streaming and long-running operations, and often provide much better performance. You may consider using a simple client instead, if a modern client is not yet available for the service you want to use, or if you are not able to use gRPC on your infrastructure.
+
+The [product documentation](https://developers.google.com/fit/rest/v1/get-started) may provide guidance regarding the preferred client library to use.
+
+## Supported Ruby versions
+
+This library is supported on Ruby 2.5+.
+
+Google provides official support for Ruby versions that are actively supported by Ruby Core -- that is, Ruby versions that are either in normal maintenance or in security maintenance, and not end of life. Currently, this means Ruby 2.5 and later. Older versions of Ruby _may_ still work, but are unsupported and not recommended. See https://www.ruby-lang.org/en/downloads/branches/ for details about the Ruby support schedule.
+
+## License
+
+This library is licensed under Apache 2.0. Full license text is available in the {file:LICENSE.md LICENSE}.
+
+## Support
+
+Please [report bugs at the project on Github](https://github.com/google/google-api-ruby-client/issues). Don't hesitate to [ask questions](http://stackoverflow.com/questions/tagged/google-api-ruby-client) about the client or APIs on [StackOverflow](http://stackoverflow.com).

data/lib/google-apis-fitness_v1.rb

@@ -0,0 +1,15 @@
+# Copyright 2020 Google LLC
+#
+# 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"

data/lib/google/apis/fitness_v1.rb

@@ -0,0 +1,99 @@
+# Copyright 2020 Google LLC
+#
+# 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'
+require 'google/apis/fitness_v1/gem_version.rb'
+
+module Google
+  module Apis
+    # Fitness API
+    #
+    # The Fitness API for managing users' fitness tracking data.
+    #
+    # @see https://developers.google.com/fit/rest/v1/get-started
+    module FitnessV1
+      # Version of the Fitness API this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1'
+
+      # Use Google Fit to see and store your physical activity data
+      AUTH_FITNESS_ACTIVITY_READ = 'https://www.googleapis.com/auth/fitness.activity.read'
+
+      # See and add to your Google Fit physical activity data
+      AUTH_FITNESS_ACTIVITY_WRITE = 'https://www.googleapis.com/auth/fitness.activity.write'
+
+      # See info about your blood glucose in Google Fit. I consent to Google sharing my blood glucose information with this app.
+      AUTH_FITNESS_BLOOD_GLUCOSE_READ = 'https://www.googleapis.com/auth/fitness.blood_glucose.read'
+
+      # See and add info about your blood glucose to Google Fit. I consent to Google sharing my blood glucose information with this app.
+      AUTH_FITNESS_BLOOD_GLUCOSE_WRITE = 'https://www.googleapis.com/auth/fitness.blood_glucose.write'
+
+      # See info about your blood pressure in Google Fit. I consent to Google sharing my blood pressure information with this app.
+      AUTH_FITNESS_BLOOD_PRESSURE_READ = 'https://www.googleapis.com/auth/fitness.blood_pressure.read'
+
+      # See and add info about your blood pressure in Google Fit. I consent to Google sharing my blood pressure information with this app.
+      AUTH_FITNESS_BLOOD_PRESSURE_WRITE = 'https://www.googleapis.com/auth/fitness.blood_pressure.write'
+
+      # See info about your body measurements and heart rate in Google Fit
+      AUTH_FITNESS_BODY_READ = 'https://www.googleapis.com/auth/fitness.body.read'
+
+      # See and add info about your body measurements and heart rate to Google Fit
+      AUTH_FITNESS_BODY_WRITE = 'https://www.googleapis.com/auth/fitness.body.write'
+
+      # See info about your body temperature in Google Fit. I consent to Google sharing my body temperature information with this app.
+      AUTH_FITNESS_BODY_TEMPERATURE_READ = 'https://www.googleapis.com/auth/fitness.body_temperature.read'
+
+      # See and add to info about your body temperature in Google Fit. I consent to Google sharing my body temperature information with this app.
+      AUTH_FITNESS_BODY_TEMPERATURE_WRITE = 'https://www.googleapis.com/auth/fitness.body_temperature.write'
+
+      # See your heart rate data in Google Fit. I consent to Google sharing my heart rate information with this app.
+      AUTH_FITNESS_HEART_RATE_READ = 'https://www.googleapis.com/auth/fitness.heart_rate.read'
+
+      # See and add to your heart rate data in Google Fit. I consent to Google sharing my heart rate information with this app.
+      AUTH_FITNESS_HEART_RATE_WRITE = 'https://www.googleapis.com/auth/fitness.heart_rate.write'
+
+      # See your Google Fit speed and distance data
+      AUTH_FITNESS_LOCATION_READ = 'https://www.googleapis.com/auth/fitness.location.read'
+
+      # See and add to your Google Fit location data
+      AUTH_FITNESS_LOCATION_WRITE = 'https://www.googleapis.com/auth/fitness.location.write'
+
+      # See info about your nutrition in Google Fit
+      AUTH_FITNESS_NUTRITION_READ = 'https://www.googleapis.com/auth/fitness.nutrition.read'
+
+      # See and add to info about your nutrition in Google Fit
+      AUTH_FITNESS_NUTRITION_WRITE = 'https://www.googleapis.com/auth/fitness.nutrition.write'
+
+      # See info about your oxygen saturation in Google Fit. I consent to Google sharing my oxygen saturation information with this app.
+      AUTH_FITNESS_OXYGEN_SATURATION_READ = 'https://www.googleapis.com/auth/fitness.oxygen_saturation.read'
+
+      # See and add info about your oxygen saturation in Google Fit. I consent to Google sharing my oxygen saturation information with this app.
+      AUTH_FITNESS_OXYGEN_SATURATION_WRITE = 'https://www.googleapis.com/auth/fitness.oxygen_saturation.write'
+
+      # See info about your reproductive health in Google Fit. I consent to Google sharing my reproductive health information with this app.
+      AUTH_FITNESS_REPRODUCTIVE_HEALTH_READ = 'https://www.googleapis.com/auth/fitness.reproductive_health.read'
+
+      # See and add info about your reproductive health in Google Fit. I consent to Google sharing my reproductive health information with this app.
+      AUTH_FITNESS_REPRODUCTIVE_HEALTH_WRITE = 'https://www.googleapis.com/auth/fitness.reproductive_health.write'
+
+      # See your sleep data in Google Fit. I consent to Google sharing my sleep information with this app.
+      AUTH_FITNESS_SLEEP_READ = 'https://www.googleapis.com/auth/fitness.sleep.read'
+
+      # See and add to your sleep data in Google Fit. I consent to Google sharing my sleep information with this app.
+      AUTH_FITNESS_SLEEP_WRITE = 'https://www.googleapis.com/auth/fitness.sleep.write'
+    end
+  end
+end

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

@@ -0,0 +1,982 @@
+# Copyright 2020 Google LLC
+#
+# 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 [Fixnum]
+        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 [Fixnum]
+        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. Only data from the specified data source ID
+        # will be included in the aggregation. If specified, this data source must exist;
+        # the OAuth scopes in the supplied credentials must grant read access to this
+        # data type. The dataset in the response will have the same data source ID. Note:
+        # Data can be aggregated by either the dataTypeName or the dataSourceId, not
+        # both.
+        # 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.android.gms:aggregated. If the user has no data for this data type,
+        # an empty data set will be returned. Note: Data can be aggregated by either the
+        # dataTypeName or the dataSourceId, not both.
+        # 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 recorded 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 [Fixnum]
+        attr_accessor :end_time_millis
+      
+        # DO NOT POPULATE THIS FIELD. It is ignored.
+        # 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 [Fixnum]
+        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 [Fixnum]
+        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 [Fixnum]
+        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 [Fixnum]
+        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
+      
+        # DO NOT USE THIS FIELD. It is ignored, and not stored.
+        # Corresponds to the JSON property `computationTimeMillis`
+        # @return [Fixnum]
+        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 [Fixnum]
+        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 [Fixnum]
+        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. WARNING: do not rely on this field for anything other than
+        # debugging. The value of this field, if it is set at all, is an implementation
+        # detail and is not guaranteed to remain consistent.
+        # 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 [Fixnum]
+        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 [Fixnum]
+        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
+      
+        # Information about an application which feeds sensor data into the platform.
+        # Corresponds to the JSON property `application`
+        # @return [Google::Apis::FitnessV1::Application]
+        attr_accessor :application
+      
+        # DO NOT POPULATE THIS FIELD. It is never populated in responses from the
+        # platform, and is ignored in queries. It will be removed in a future version
+        # entirely.
+        # 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 make up the data stream ID are absent, they will be
+        # omitted from the data stream ID. The minimum viable data stream ID would be:
+        # type:dataType.name:developer project number Finally, the developer project
+        # number and device UID are 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. This means a client will
+        # see a different set of data_stream_ids than another client with different
+        # credentials.
+        # 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
+      
+        # The data type defines the schema for a stream of data being collected by,
+        # inserted into, or queried from the Fitness API.
+        # 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 second part of the dataset identifier.
+        # Corresponds to the JSON property `maxEndTimeNs`
+        # @return [Fixnum]
+        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 [Fixnum]
+        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
+        # endTimeNanos. 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. The obfuscation preserves equality; that is, given two IDs, if
+        # id1 == id2, obfuscated(id1) == obfuscated(id2).
+        # 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 ListDataPointChangesResponse
+        include Google::Apis::Core::Hashable
+      
+        # The data stream ID of the data source with data point changes.
+        # Corresponds to the JSON property `dataSourceId`
+        # @return [String]
+        attr_accessor :data_source_id
+      
+        # Deleted data points for the user. Note, for modifications this should be
+        # parsed before handling insertions.
+        # Corresponds to the JSON property `deletedDataPoint`
+        # @return [Array<Google::Apis::FitnessV1::DataPoint>]
+        attr_accessor :deleted_data_point
+      
+        # Inserted data points for the user.
+        # Corresponds to the JSON property `insertedDataPoint`
+        # @return [Array<Google::Apis::FitnessV1::DataPoint>]
+        attr_accessor :inserted_data_point
+      
+        # 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
+      
+        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)
+          @deleted_data_point = args[:deleted_data_point] if args.key?(:deleted_data_point)
+          @inserted_data_point = args[:inserted_data_point] if args.key?(:inserted_data_point)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        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, and startTime and endTime are
+        # omitted, this will include sessions which were deleted since the last sync.
+        # 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. DO NOT USE THIS FIELD. It
+        # is never populated in responses from the server.
+        # Corresponds to the JSON property `hasMoreData`
+        # @return [Boolean]
+        attr_accessor :has_more_data
+        alias_method :has_more_data?, :has_more_data
+      
+        # The sync token which is used to sync further changes. This will only be
+        # provided if both startTime and endTime are omitted from the request.
+        # 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 [Fixnum]
+        attr_accessor :active_time_millis
+      
+        # The type of activity this session represents.
+        # Corresponds to the JSON property `activityType`
+        # @return [Fixnum]
+        attr_accessor :activity_type
+      
+        # The application that created the session.
+        # 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 [Fixnum]
+        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 [Fixnum]
+        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 [Fixnum]
+        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.
+      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