google-apis-androidmanagement_v1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9710b73579f5de5ca6adf212c4310c98964740e7dd7edf397637bc1d1a3a7535
+  data.tar.gz: fee85aed7575aea1256b705f3269e4929218dc31b3d6d5d0198be1838e02c1e9
+SHA512:
+  metadata.gz: 3e5b2475dc308794494832c67eb6b2c7b07791ce851428d0ed3fe12060a14c080f2cfa0451129d140418ac427995dc9495262e8364d8a52505e94a1ae63bc367
+  data.tar.gz: d74d2c2e56c664db3bfec711cbf7b4e78cde4855994bb39b2765da923924ec867edb65e3dbcc1507177f455811721dbf59d9dd4a85b45d057db818f1c0c0d28c

data/.yardopts

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

data/CHANGELOG.md

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

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 Android Management API
+
+This is a simple client library for version V1 of the Android Management 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/androidmanagement.googleapis.com) in the console.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google-apis-androidmanagement_v1', '~> 0.1'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install google-apis-androidmanagement_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/androidmanagement_v1"
+
+# Create a client object
+client = Google::Apis::AndroidmanagementV1::AndroidManagementService.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 Androidmanagement service in particular.)
+
+For reference information on specific calls in the Android Management API, see the {Google::Apis::AndroidmanagementV1::AndroidManagementService 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-androidmanagement_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/android/management) 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-androidmanagement_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/androidmanagement_v1"

data/lib/google/apis/androidmanagement_v1.rb

@@ -0,0 +1,37 @@
+# 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/androidmanagement_v1/service.rb'
+require 'google/apis/androidmanagement_v1/classes.rb'
+require 'google/apis/androidmanagement_v1/representations.rb'
+require 'google/apis/androidmanagement_v1/gem_version.rb'
+
+module Google
+  module Apis
+    # Android Management API
+    #
+    # The Android Management API provides remote enterprise management of Android
+    # devices and apps.
+    #
+    # @see https://developers.google.com/android/management
+    module AndroidmanagementV1
+      # Version of the Android Management API this client connects to.
+      # This is NOT the gem version.
+      VERSION = 'V1'
+
+      # Manage Android devices and apps for your customers
+      AUTH_ANDROIDMANAGEMENT = 'https://www.googleapis.com/auth/androidmanagement'
+    end
+  end
+end

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

@@ -0,0 +1,3767 @@
+# 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 AndroidmanagementV1
+      
+      # Security policies set to the most secure values by default. To maintain the
+      # security posture of a device, we don't recommend overriding any of the default
+      # values.
+      class AdvancedSecurityOverrides
+        include Google::Apis::Core::Hashable
+      
+        # Controls Common Criteria Mode—security standards defined in the Common
+        # Criteria for Information Technology Security Evaluation (https://www.
+        # commoncriteriaportal.org/) (CC). Enabling Common Criteria Mode increases
+        # certain security components on a device, including AES-GCM encryption of
+        # Bluetooth Long Term Keys, and Wi-Fi configuration stores.Warning: Common
+        # Criteria Mode enforces a strict security model typically only required for IT
+        # products used in national security systems and other highly sensitive
+        # organizations. Standard device use may be affected. Only enabled if required.
+        # Corresponds to the JSON property `commonCriteriaMode`
+        # @return [String]
+        attr_accessor :common_criteria_mode
+      
+        # The policy for untrusted apps (apps from unknown sources) enforced on the
+        # device. Replaces install_unknown_sources_allowed (deprecated).
+        # Corresponds to the JSON property `untrustedAppsPolicy`
+        # @return [String]
+        attr_accessor :untrusted_apps_policy
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @common_criteria_mode = args[:common_criteria_mode] if args.key?(:common_criteria_mode)
+          @untrusted_apps_policy = args[:untrusted_apps_policy] if args.key?(:untrusted_apps_policy)
+        end
+      end
+      
+      # Configuration for an always-on VPN connection.
+      class AlwaysOnVpnPackage
+        include Google::Apis::Core::Hashable
+      
+        # Disallows networking when the VPN is not connected.
+        # Corresponds to the JSON property `lockdownEnabled`
+        # @return [Boolean]
+        attr_accessor :lockdown_enabled
+        alias_method :lockdown_enabled?, :lockdown_enabled
+      
+        # The package name of the VPN app.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @lockdown_enabled = args[:lockdown_enabled] if args.key?(:lockdown_enabled)
+          @package_name = args[:package_name] if args.key?(:package_name)
+        end
+      end
+      
+      # A compliance rule condition which is satisfied if the Android Framework API
+      # level on the device doesn't meet a minimum requirement. There can only be one
+      # rule with this type of condition per policy.
+      class ApiLevelCondition
+        include Google::Apis::Core::Hashable
+      
+        # The minimum desired Android Framework API level. If the device doesn't meet
+        # the minimum requirement, this condition is satisfied. Must be greater than
+        # zero.
+        # Corresponds to the JSON property `minApiLevel`
+        # @return [Fixnum]
+        attr_accessor :min_api_level
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @min_api_level = args[:min_api_level] if args.key?(:min_api_level)
+        end
+      end
+      
+      # Id to name association of a app track.
+      class AppTrackInfo
+        include Google::Apis::Core::Hashable
+      
+        # The track name associated with the trackId, set in the Play Console. The name
+        # is modifiable from Play Console.
+        # Corresponds to the JSON property `trackAlias`
+        # @return [String]
+        attr_accessor :track_alias
+      
+        # The unmodifiable unique track identifier, taken from the releaseTrackId in the
+        # URL of the Play Console page that displays the app’s track information.
+        # Corresponds to the JSON property `trackId`
+        # @return [String]
+        attr_accessor :track_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @track_alias = args[:track_alias] if args.key?(:track_alias)
+          @track_id = args[:track_id] if args.key?(:track_id)
+        end
+      end
+      
+      # Information about an app.
+      class Application
+        include Google::Apis::Core::Hashable
+      
+        # Application tracks visible to the enterprise.
+        # Corresponds to the JSON property `appTracks`
+        # @return [Array<Google::Apis::AndroidmanagementV1::AppTrackInfo>]
+        attr_accessor :app_tracks
+      
+        # The set of managed properties available to be pre-configured for the app.
+        # Corresponds to the JSON property `managedProperties`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ManagedProperty>]
+        attr_accessor :managed_properties
+      
+        # The name of the app in the form enterprises/`enterpriseId`/applications/`
+        # package_name`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The permissions required by the app.
+        # Corresponds to the JSON property `permissions`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ApplicationPermission>]
+        attr_accessor :permissions
+      
+        # The title of the app. Localized.
+        # Corresponds to the JSON property `title`
+        # @return [String]
+        attr_accessor :title
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @app_tracks = args[:app_tracks] if args.key?(:app_tracks)
+          @managed_properties = args[:managed_properties] if args.key?(:managed_properties)
+          @name = args[:name] if args.key?(:name)
+          @permissions = args[:permissions] if args.key?(:permissions)
+          @title = args[:title] if args.key?(:title)
+        end
+      end
+      
+      # An app-related event.
+      class ApplicationEvent
+        include Google::Apis::Core::Hashable
+      
+        # The creation time of the event.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # App event type.
+        # Corresponds to the JSON property `eventType`
+        # @return [String]
+        attr_accessor :event_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @event_type = args[:event_type] if args.key?(:event_type)
+        end
+      end
+      
+      # A permission required by the app.
+      class ApplicationPermission
+        include Google::Apis::Core::Hashable
+      
+        # A longer description of the permission, providing more detail on what it
+        # affects. Localized.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # The name of the permission. Localized.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # An opaque string uniquely identifying the permission. Not localized.
+        # Corresponds to the JSON property `permissionId`
+        # @return [String]
+        attr_accessor :permission_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @description = args[:description] if args.key?(:description)
+          @name = args[:name] if args.key?(:name)
+          @permission_id = args[:permission_id] if args.key?(:permission_id)
+        end
+      end
+      
+      # Policy for an individual app.
+      class ApplicationPolicy
+        include Google::Apis::Core::Hashable
+      
+        # List of the app’s track IDs that a device belonging to the enterprise can
+        # access. If the list contains multiple track IDs, devices receive the latest
+        # version among all accessible tracks. If the list contains no track IDs,
+        # devices only have access to the app’s production track. More details about
+        # each track are available in AppTrackInfo.
+        # Corresponds to the JSON property `accessibleTrackIds`
+        # @return [Array<String>]
+        attr_accessor :accessible_track_ids
+      
+        # This feature is not generally available.
+        # Corresponds to the JSON property `autoUpdateMode`
+        # @return [String]
+        attr_accessor :auto_update_mode
+      
+        # Controls whether the app can communicate with itself across a device’s work
+        # and personal profiles, subject to user consent.
+        # Corresponds to the JSON property `connectedWorkAndPersonalApp`
+        # @return [String]
+        attr_accessor :connected_work_and_personal_app
+      
+        # The default policy for all permissions requested by the app. If specified,
+        # this overrides the policy-level default_permission_policy which applies to all
+        # apps. It does not override the permission_grants which applies to all apps.
+        # Corresponds to the JSON property `defaultPermissionPolicy`
+        # @return [String]
+        attr_accessor :default_permission_policy
+      
+        # The scopes delegated to the app from Android Device Policy.
+        # Corresponds to the JSON property `delegatedScopes`
+        # @return [Array<String>]
+        attr_accessor :delegated_scopes
+      
+        # Whether the app is disabled. When disabled, the app data is still preserved.
+        # Corresponds to the JSON property `disabled`
+        # @return [Boolean]
+        attr_accessor :disabled
+        alias_method :disabled?, :disabled
+      
+        # The type of installation to perform.
+        # Corresponds to the JSON property `installType`
+        # @return [String]
+        attr_accessor :install_type
+      
+        # Whether the app is allowed to lock itself in full-screen mode. DEPRECATED. Use
+        # InstallType KIOSK or kioskCustomLauncherEnabled to to configure a dedicated
+        # device.
+        # Corresponds to the JSON property `lockTaskAllowed`
+        # @return [Boolean]
+        attr_accessor :lock_task_allowed
+        alias_method :lock_task_allowed?, :lock_task_allowed
+      
+        # Managed configuration applied to the app. The format for the configuration is
+        # dictated by the ManagedProperty values supported by the app. Each field name
+        # in the managed configuration must match the key field of the ManagedProperty.
+        # The field value must be compatible with the type of the ManagedProperty: *type*
+        # *JSON value* BOOL true or false STRING string INTEGER number CHOICE string
+        # MULTISELECT array of strings HIDDEN string BUNDLE_ARRAY array of objects
+        # Corresponds to the JSON property `managedConfiguration`
+        # @return [Hash<String,Object>]
+        attr_accessor :managed_configuration
+      
+        # The managed configurations template for the app, saved from the managed
+        # configurations iframe.
+        # Corresponds to the JSON property `managedConfigurationTemplate`
+        # @return [Google::Apis::AndroidmanagementV1::ManagedConfigurationTemplate]
+        attr_accessor :managed_configuration_template
+      
+        # The minimum version of the app that runs on the device. If set, the device
+        # attempts to update the app to at least this version code. If the app is not up-
+        # to-date, the device will contain a NonComplianceDetail with
+        # non_compliance_reason set to APP_NOT_UPDATED. The app must already be
+        # published to Google Play with a version code greater than or equal to this
+        # value. At most 20 apps may specify a minimum version code per policy.
+        # Corresponds to the JSON property `minimumVersionCode`
+        # @return [Fixnum]
+        attr_accessor :minimum_version_code
+      
+        # The package name of the app. For example, com.google.android.youtube for the
+        # YouTube app.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        # Explicit permission grants or denials for the app. These values override the
+        # default_permission_policy and permission_grants which apply to all apps.
+        # Corresponds to the JSON property `permissionGrants`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PermissionGrant>]
+        attr_accessor :permission_grants
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @accessible_track_ids = args[:accessible_track_ids] if args.key?(:accessible_track_ids)
+          @auto_update_mode = args[:auto_update_mode] if args.key?(:auto_update_mode)
+          @connected_work_and_personal_app = args[:connected_work_and_personal_app] if args.key?(:connected_work_and_personal_app)
+          @default_permission_policy = args[:default_permission_policy] if args.key?(:default_permission_policy)
+          @delegated_scopes = args[:delegated_scopes] if args.key?(:delegated_scopes)
+          @disabled = args[:disabled] if args.key?(:disabled)
+          @install_type = args[:install_type] if args.key?(:install_type)
+          @lock_task_allowed = args[:lock_task_allowed] if args.key?(:lock_task_allowed)
+          @managed_configuration = args[:managed_configuration] if args.key?(:managed_configuration)
+          @managed_configuration_template = args[:managed_configuration_template] if args.key?(:managed_configuration_template)
+          @minimum_version_code = args[:minimum_version_code] if args.key?(:minimum_version_code)
+          @package_name = args[:package_name] if args.key?(:package_name)
+          @permission_grants = args[:permission_grants] if args.key?(:permission_grants)
+        end
+      end
+      
+      # Information reported about an installed app.
+      class ApplicationReport
+        include Google::Apis::Core::Hashable
+      
+        # The source of the package.
+        # Corresponds to the JSON property `applicationSource`
+        # @return [String]
+        attr_accessor :application_source
+      
+        # The display name of the app.
+        # Corresponds to the JSON property `displayName`
+        # @return [String]
+        attr_accessor :display_name
+      
+        # List of app events. The most recent 20 events are stored in the list.
+        # Corresponds to the JSON property `events`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ApplicationEvent>]
+        attr_accessor :events
+      
+        # The package name of the app that installed this app.
+        # Corresponds to the JSON property `installerPackageName`
+        # @return [String]
+        attr_accessor :installer_package_name
+      
+        # List of keyed app states reported by the app.
+        # Corresponds to the JSON property `keyedAppStates`
+        # @return [Array<Google::Apis::AndroidmanagementV1::KeyedAppState>]
+        attr_accessor :keyed_app_states
+      
+        # Package name of the app.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        # The SHA-256 hash of the app's APK file, which can be used to verify the app
+        # hasn't been modified. Each byte of the hash value is represented as a two-
+        # digit hexadecimal number.
+        # Corresponds to the JSON property `packageSha256Hash`
+        # @return [String]
+        attr_accessor :package_sha256_hash
+      
+        # The SHA-1 hash of each android.content.pm.Signature (https://developer.android.
+        # com/reference/android/content/pm/Signature.html) associated with the app
+        # package. Each byte of each hash value is represented as a two-digit
+        # hexadecimal number.
+        # Corresponds to the JSON property `signingKeyCertFingerprints`
+        # @return [Array<String>]
+        attr_accessor :signing_key_cert_fingerprints
+      
+        # Application state.
+        # Corresponds to the JSON property `state`
+        # @return [String]
+        attr_accessor :state
+      
+        # The app version code, which can be used to determine whether one version is
+        # more recent than another.
+        # Corresponds to the JSON property `versionCode`
+        # @return [Fixnum]
+        attr_accessor :version_code
+      
+        # The app version as displayed to the user.
+        # Corresponds to the JSON property `versionName`
+        # @return [String]
+        attr_accessor :version_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @application_source = args[:application_source] if args.key?(:application_source)
+          @display_name = args[:display_name] if args.key?(:display_name)
+          @events = args[:events] if args.key?(:events)
+          @installer_package_name = args[:installer_package_name] if args.key?(:installer_package_name)
+          @keyed_app_states = args[:keyed_app_states] if args.key?(:keyed_app_states)
+          @package_name = args[:package_name] if args.key?(:package_name)
+          @package_sha256_hash = args[:package_sha256_hash] if args.key?(:package_sha256_hash)
+          @signing_key_cert_fingerprints = args[:signing_key_cert_fingerprints] if args.key?(:signing_key_cert_fingerprints)
+          @state = args[:state] if args.key?(:state)
+          @version_code = args[:version_code] if args.key?(:version_code)
+          @version_name = args[:version_name] if args.key?(:version_name)
+        end
+      end
+      
+      # Settings controlling the behavior of application reports.
+      class ApplicationReportingSettings
+        include Google::Apis::Core::Hashable
+      
+        # Whether removed apps are included in application reports.
+        # Corresponds to the JSON property `includeRemovedApps`
+        # @return [Boolean]
+        attr_accessor :include_removed_apps
+        alias_method :include_removed_apps?, :include_removed_apps
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @include_removed_apps = args[:include_removed_apps] if args.key?(:include_removed_apps)
+        end
+      end
+      
+      # An action to block access to apps and data on a fully managed device or in a
+      # work profile. This action also triggers a device or work profile to displays a
+      # user-facing notification with information (where possible) on how to correct
+      # the compliance issue. Note: wipeAction must also be specified.
+      class BlockAction
+        include Google::Apis::Core::Hashable
+      
+        # Number of days the policy is non-compliant before the device or work profile
+        # is blocked. To block access immediately, set to 0. blockAfterDays must be less
+        # than wipeAfterDays.
+        # Corresponds to the JSON property `blockAfterDays`
+        # @return [Fixnum]
+        attr_accessor :block_after_days
+      
+        # Specifies the scope of this BlockAction. Only applicable to devices that are
+        # company-owned.
+        # Corresponds to the JSON property `blockScope`
+        # @return [String]
+        attr_accessor :block_scope
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @block_after_days = args[:block_after_days] if args.key?(:block_after_days)
+          @block_scope = args[:block_scope] if args.key?(:block_scope)
+        end
+      end
+      
+      # A rule for automatically choosing a private key and certificate to
+      # authenticate the device to a server.
+      class ChoosePrivateKeyRule
+        include Google::Apis::Core::Hashable
+      
+        # The package names for which outgoing requests are subject to this rule. If no
+        # package names are specified, then the rule applies to all packages. For each
+        # package name listed, the rule applies to that package and all other packages
+        # that shared the same Android UID. The SHA256 hash of the signing key
+        # signatures of each package_name will be verified against those provided by
+        # Play
+        # Corresponds to the JSON property `packageNames`
+        # @return [Array<String>]
+        attr_accessor :package_names
+      
+        # The alias of the private key to be used.
+        # Corresponds to the JSON property `privateKeyAlias`
+        # @return [String]
+        attr_accessor :private_key_alias
+      
+        # The URL pattern to match against the URL of the outgoing request. The pattern
+        # may contain asterisk (*) wildcards. Any URL is matched if unspecified.
+        # Corresponds to the JSON property `urlPattern`
+        # @return [String]
+        attr_accessor :url_pattern
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @package_names = args[:package_names] if args.key?(:package_names)
+          @private_key_alias = args[:private_key_alias] if args.key?(:private_key_alias)
+          @url_pattern = args[:url_pattern] if args.key?(:url_pattern)
+        end
+      end
+      
+      # A command.
+      class Command
+        include Google::Apis::Core::Hashable
+      
+        # The timestamp at which the command was created. The timestamp is automatically
+        # generated by the server.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # The duration for which the command is valid. The command will expire if not
+        # executed by the device during this time. The default duration if unspecified
+        # is ten minutes. There is no maximum duration.
+        # Corresponds to the JSON property `duration`
+        # @return [String]
+        attr_accessor :duration
+      
+        # If the command failed, an error code explaining the failure. This is not set
+        # when the command is cancelled by the caller.
+        # Corresponds to the JSON property `errorCode`
+        # @return [String]
+        attr_accessor :error_code
+      
+        # For commands of type RESET_PASSWORD, optionally specifies the new password.
+        # Corresponds to the JSON property `newPassword`
+        # @return [String]
+        attr_accessor :new_password
+      
+        # For commands of type RESET_PASSWORD, optionally specifies flags.
+        # Corresponds to the JSON property `resetPasswordFlags`
+        # @return [Array<String>]
+        attr_accessor :reset_password_flags
+      
+        # The type of the command.
+        # Corresponds to the JSON property `type`
+        # @return [String]
+        attr_accessor :type
+      
+        # The resource name of the user that owns the device in the form enterprises/`
+        # enterpriseId`/users/`userId`. This is automatically generated by the server
+        # based on the device the command is sent to.
+        # Corresponds to the JSON property `userName`
+        # @return [String]
+        attr_accessor :user_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @duration = args[:duration] if args.key?(:duration)
+          @error_code = args[:error_code] if args.key?(:error_code)
+          @new_password = args[:new_password] if args.key?(:new_password)
+          @reset_password_flags = args[:reset_password_flags] if args.key?(:reset_password_flags)
+          @type = args[:type] if args.key?(:type)
+          @user_name = args[:user_name] if args.key?(:user_name)
+        end
+      end
+      
+      # Information about Common Criteria Mode—security standards defined in the
+      # Common Criteria for Information Technology Security Evaluation (https://www.
+      # commoncriteriaportal.org/) (CC).This information is only available if
+      # statusReportingSettings.commonCriteriaModeEnabled is true in the device's
+      # policy.
+      class CommonCriteriaModeInfo
+        include Google::Apis::Core::Hashable
+      
+        # Whether Common Criteria Mode is enabled.
+        # Corresponds to the JSON property `commonCriteriaModeStatus`
+        # @return [String]
+        attr_accessor :common_criteria_mode_status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @common_criteria_mode_status = args[:common_criteria_mode_status] if args.key?(:common_criteria_mode_status)
+        end
+      end
+      
+      # A rule declaring which mitigating actions to take when a device is not
+      # compliant with its policy. For every rule, there is always an implicit
+      # mitigating action to set policy_compliant to false for the Device resource,
+      # and display a message on the device indicating that the device is not
+      # compliant with its policy. Other mitigating actions may optionally be taken as
+      # well, depending on the field values in the rule.
+      class ComplianceRule
+        include Google::Apis::Core::Hashable
+      
+        # A compliance rule condition which is satisfied if the Android Framework API
+        # level on the device doesn't meet a minimum requirement. There can only be one
+        # rule with this type of condition per policy.
+        # Corresponds to the JSON property `apiLevelCondition`
+        # @return [Google::Apis::AndroidmanagementV1::ApiLevelCondition]
+        attr_accessor :api_level_condition
+      
+        # If set to true, the rule includes a mitigating action to disable apps so that
+        # the device is effectively disabled, but app data is preserved. If the device
+        # is running an app in locked task mode, the app will be closed and a UI showing
+        # the reason for non-compliance will be displayed.
+        # Corresponds to the JSON property `disableApps`
+        # @return [Boolean]
+        attr_accessor :disable_apps
+        alias_method :disable_apps?, :disable_apps
+      
+        # A compliance rule condition which is satisfied if there exists any matching
+        # NonComplianceDetail for the device. A NonComplianceDetail matches a
+        # NonComplianceDetailCondition if all the fields which are set within the
+        # NonComplianceDetailCondition match the corresponding NonComplianceDetail
+        # fields.
+        # Corresponds to the JSON property `nonComplianceDetailCondition`
+        # @return [Google::Apis::AndroidmanagementV1::NonComplianceDetailCondition]
+        attr_accessor :non_compliance_detail_condition
+      
+        # If set, the rule includes a mitigating action to disable apps specified in the
+        # list, but app data is preserved.
+        # Corresponds to the JSON property `packageNamesToDisable`
+        # @return [Array<String>]
+        attr_accessor :package_names_to_disable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @api_level_condition = args[:api_level_condition] if args.key?(:api_level_condition)
+          @disable_apps = args[:disable_apps] if args.key?(:disable_apps)
+          @non_compliance_detail_condition = args[:non_compliance_detail_condition] if args.key?(:non_compliance_detail_condition)
+          @package_names_to_disable = args[:package_names_to_disable] if args.key?(:package_names_to_disable)
+        end
+      end
+      
+      # Represents a whole or partial calendar date, such as a birthday. The time of
+      # day and time zone are either specified elsewhere or are insignificant. The
+      # date is relative to the Gregorian Calendar. This can represent one of the
+      # following: A full date, with non-zero year, month, and day values A month and
+      # day value, with a zero year, such as an anniversary A year on its own, with
+      # zero month and day values A year and month value, with a zero day, such as a
+      # credit card expiration dateRelated types are google.type.TimeOfDay and google.
+      # protobuf.Timestamp.
+      class Date
+        include Google::Apis::Core::Hashable
+      
+        # Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to
+        # specify a year by itself or a year and month where the day isn't significant.
+        # Corresponds to the JSON property `day`
+        # @return [Fixnum]
+        attr_accessor :day
+      
+        # Month of a year. Must be from 1 to 12, or 0 to specify a year without a month
+        # and day.
+        # Corresponds to the JSON property `month`
+        # @return [Fixnum]
+        attr_accessor :month
+      
+        # Year of the date. Must be from 1 to 9999, or 0 to specify a date without a
+        # year.
+        # Corresponds to the JSON property `year`
+        # @return [Fixnum]
+        attr_accessor :year
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @day = args[:day] if args.key?(:day)
+          @month = args[:month] if args.key?(:month)
+          @year = args[:year] if args.key?(:year)
+        end
+      end
+      
+      # A device owned by an enterprise. Unless otherwise noted, all fields are read-
+      # only and can't be modified by enterprises.devices.patch.
+      class Device
+        include Google::Apis::Core::Hashable
+      
+        # The API level of the Android platform version running on the device.
+        # Corresponds to the JSON property `apiLevel`
+        # @return [Fixnum]
+        attr_accessor :api_level
+      
+        # Reports for apps installed on the device. This information is only available
+        # when application_reports_enabled is true in the device's policy.
+        # Corresponds to the JSON property `applicationReports`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ApplicationReport>]
+        attr_accessor :application_reports
+      
+        # The name of the policy currently applied to the device.
+        # Corresponds to the JSON property `appliedPolicyName`
+        # @return [String]
+        attr_accessor :applied_policy_name
+      
+        # The version of the policy currently applied to the device.
+        # Corresponds to the JSON property `appliedPolicyVersion`
+        # @return [Fixnum]
+        attr_accessor :applied_policy_version
+      
+        # The state currently applied to the device.
+        # Corresponds to the JSON property `appliedState`
+        # @return [String]
+        attr_accessor :applied_state
+      
+        # Information about Common Criteria Mode—security standards defined in the
+        # Common Criteria for Information Technology Security Evaluation (https://www.
+        # commoncriteriaportal.org/) (CC).This information is only available if
+        # statusReportingSettings.commonCriteriaModeEnabled is true in the device's
+        # policy.
+        # Corresponds to the JSON property `commonCriteriaModeInfo`
+        # @return [Google::Apis::AndroidmanagementV1::CommonCriteriaModeInfo]
+        attr_accessor :common_criteria_mode_info
+      
+        # Information about security related device settings on device.
+        # Corresponds to the JSON property `deviceSettings`
+        # @return [Google::Apis::AndroidmanagementV1::DeviceSettings]
+        attr_accessor :device_settings
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `disabledReason`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :disabled_reason
+      
+        # Detailed information about displays on the device. This information is only
+        # available if displayInfoEnabled is true in the device's policy.
+        # Corresponds to the JSON property `displays`
+        # @return [Array<Google::Apis::AndroidmanagementV1::DisplayProp>]
+        attr_accessor :displays
+      
+        # The time of device enrollment.
+        # Corresponds to the JSON property `enrollmentTime`
+        # @return [String]
+        attr_accessor :enrollment_time
+      
+        # If the device was enrolled with an enrollment token with additional data
+        # provided, this field contains that data.
+        # Corresponds to the JSON property `enrollmentTokenData`
+        # @return [String]
+        attr_accessor :enrollment_token_data
+      
+        # If the device was enrolled with an enrollment token, this field contains the
+        # name of the token.
+        # Corresponds to the JSON property `enrollmentTokenName`
+        # @return [String]
+        attr_accessor :enrollment_token_name
+      
+        # Information about device hardware. The fields related to temperature
+        # thresholds are only available if hardwareStatusEnabled is true in the device's
+        # policy.
+        # Corresponds to the JSON property `hardwareInfo`
+        # @return [Google::Apis::AndroidmanagementV1::HardwareInfo]
+        attr_accessor :hardware_info
+      
+        # Hardware status samples in chronological order. This information is only
+        # available if hardwareStatusEnabled is true in the device's policy.
+        # Corresponds to the JSON property `hardwareStatusSamples`
+        # @return [Array<Google::Apis::AndroidmanagementV1::HardwareStatus>]
+        attr_accessor :hardware_status_samples
+      
+        # Deprecated.
+        # Corresponds to the JSON property `lastPolicyComplianceReportTime`
+        # @return [String]
+        attr_accessor :last_policy_compliance_report_time
+      
+        # The last time the device fetched its policy.
+        # Corresponds to the JSON property `lastPolicySyncTime`
+        # @return [String]
+        attr_accessor :last_policy_sync_time
+      
+        # The last time the device sent a status report.
+        # Corresponds to the JSON property `lastStatusReportTime`
+        # @return [String]
+        attr_accessor :last_status_report_time
+      
+        # The type of management mode Android Device Policy takes on the device. This
+        # influences which policy settings are supported.
+        # Corresponds to the JSON property `managementMode`
+        # @return [String]
+        attr_accessor :management_mode
+      
+        # Events related to memory and storage measurements in chronological order. This
+        # information is only available if memoryInfoEnabled is true in the device's
+        # policy.
+        # Corresponds to the JSON property `memoryEvents`
+        # @return [Array<Google::Apis::AndroidmanagementV1::MemoryEvent>]
+        attr_accessor :memory_events
+      
+        # Information about device memory and storage.
+        # Corresponds to the JSON property `memoryInfo`
+        # @return [Google::Apis::AndroidmanagementV1::MemoryInfo]
+        attr_accessor :memory_info
+      
+        # The name of the device in the form enterprises/`enterpriseId`/devices/`
+        # deviceId`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Device network info.
+        # Corresponds to the JSON property `networkInfo`
+        # @return [Google::Apis::AndroidmanagementV1::NetworkInfo]
+        attr_accessor :network_info
+      
+        # Details about policy settings that the device is not compliant with.
+        # Corresponds to the JSON property `nonComplianceDetails`
+        # @return [Array<Google::Apis::AndroidmanagementV1::NonComplianceDetail>]
+        attr_accessor :non_compliance_details
+      
+        # Ownership of the managed device.
+        # Corresponds to the JSON property `ownership`
+        # @return [String]
+        attr_accessor :ownership
+      
+        # Whether the device is compliant with its policy.
+        # Corresponds to the JSON property `policyCompliant`
+        # @return [Boolean]
+        attr_accessor :policy_compliant
+        alias_method :policy_compliant?, :policy_compliant
+      
+        # The name of the policy applied to the device, in the form enterprises/`
+        # enterpriseId`/policies/`policyId`. If not specified, the policy_name for the
+        # device's user is applied. This field can be modified by a patch request. You
+        # can specify only the policyId when calling enterprises.devices.patch, as long
+        # as the policyId doesn’t contain any slashes. The rest of the policy name is
+        # inferred.
+        # Corresponds to the JSON property `policyName`
+        # @return [String]
+        attr_accessor :policy_name
+      
+        # Power management events on the device in chronological order. This information
+        # is only available if powerManagementEventsEnabled is true in the device's
+        # policy.
+        # Corresponds to the JSON property `powerManagementEvents`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PowerManagementEvent>]
+        attr_accessor :power_management_events
+      
+        # If the same physical device has been enrolled multiple times, this field
+        # contains its previous device names. The serial number is used as the unique
+        # identifier to determine if the same physical device has enrolled previously.
+        # The names are in chronological order.
+        # Corresponds to the JSON property `previousDeviceNames`
+        # @return [Array<String>]
+        attr_accessor :previous_device_names
+      
+        # The security posture of the device, as determined by the current device state
+        # and the policies applied.
+        # Corresponds to the JSON property `securityPosture`
+        # @return [Google::Apis::AndroidmanagementV1::SecurityPosture]
+        attr_accessor :security_posture
+      
+        # Information about device software.
+        # Corresponds to the JSON property `softwareInfo`
+        # @return [Google::Apis::AndroidmanagementV1::SoftwareInfo]
+        attr_accessor :software_info
+      
+        # The state to be applied to the device. This field can be modified by a patch
+        # request. Note that when calling enterprises.devices.patch, ACTIVE and DISABLED
+        # are the only allowable values. To enter the device into a DELETED state, call
+        # enterprises.devices.delete.
+        # Corresponds to the JSON property `state`
+        # @return [String]
+        attr_accessor :state
+      
+        # Map of selected system properties name and value related to the device. This
+        # information is only available if systemPropertiesEnabled is true in the device'
+        # s policy.
+        # Corresponds to the JSON property `systemProperties`
+        # @return [Hash<String,String>]
+        attr_accessor :system_properties
+      
+        # A user belonging to an enterprise.
+        # Corresponds to the JSON property `user`
+        # @return [Google::Apis::AndroidmanagementV1::User]
+        attr_accessor :user
+      
+        # The resource name of the user that owns this device in the form enterprises/`
+        # enterpriseId`/users/`userId`.
+        # Corresponds to the JSON property `userName`
+        # @return [String]
+        attr_accessor :user_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @api_level = args[:api_level] if args.key?(:api_level)
+          @application_reports = args[:application_reports] if args.key?(:application_reports)
+          @applied_policy_name = args[:applied_policy_name] if args.key?(:applied_policy_name)
+          @applied_policy_version = args[:applied_policy_version] if args.key?(:applied_policy_version)
+          @applied_state = args[:applied_state] if args.key?(:applied_state)
+          @common_criteria_mode_info = args[:common_criteria_mode_info] if args.key?(:common_criteria_mode_info)
+          @device_settings = args[:device_settings] if args.key?(:device_settings)
+          @disabled_reason = args[:disabled_reason] if args.key?(:disabled_reason)
+          @displays = args[:displays] if args.key?(:displays)
+          @enrollment_time = args[:enrollment_time] if args.key?(:enrollment_time)
+          @enrollment_token_data = args[:enrollment_token_data] if args.key?(:enrollment_token_data)
+          @enrollment_token_name = args[:enrollment_token_name] if args.key?(:enrollment_token_name)
+          @hardware_info = args[:hardware_info] if args.key?(:hardware_info)
+          @hardware_status_samples = args[:hardware_status_samples] if args.key?(:hardware_status_samples)
+          @last_policy_compliance_report_time = args[:last_policy_compliance_report_time] if args.key?(:last_policy_compliance_report_time)
+          @last_policy_sync_time = args[:last_policy_sync_time] if args.key?(:last_policy_sync_time)
+          @last_status_report_time = args[:last_status_report_time] if args.key?(:last_status_report_time)
+          @management_mode = args[:management_mode] if args.key?(:management_mode)
+          @memory_events = args[:memory_events] if args.key?(:memory_events)
+          @memory_info = args[:memory_info] if args.key?(:memory_info)
+          @name = args[:name] if args.key?(:name)
+          @network_info = args[:network_info] if args.key?(:network_info)
+          @non_compliance_details = args[:non_compliance_details] if args.key?(:non_compliance_details)
+          @ownership = args[:ownership] if args.key?(:ownership)
+          @policy_compliant = args[:policy_compliant] if args.key?(:policy_compliant)
+          @policy_name = args[:policy_name] if args.key?(:policy_name)
+          @power_management_events = args[:power_management_events] if args.key?(:power_management_events)
+          @previous_device_names = args[:previous_device_names] if args.key?(:previous_device_names)
+          @security_posture = args[:security_posture] if args.key?(:security_posture)
+          @software_info = args[:software_info] if args.key?(:software_info)
+          @state = args[:state] if args.key?(:state)
+          @system_properties = args[:system_properties] if args.key?(:system_properties)
+          @user = args[:user] if args.key?(:user)
+          @user_name = args[:user_name] if args.key?(:user_name)
+        end
+      end
+      
+      # Information about security related device settings on device.
+      class DeviceSettings
+        include Google::Apis::Core::Hashable
+      
+        # Whether ADB (https://developer.android.com/studio/command-line/adb.html) is
+        # enabled on the device.
+        # Corresponds to the JSON property `adbEnabled`
+        # @return [Boolean]
+        attr_accessor :adb_enabled
+        alias_method :adb_enabled?, :adb_enabled
+      
+        # Whether developer mode is enabled on the device.
+        # Corresponds to the JSON property `developmentSettingsEnabled`
+        # @return [Boolean]
+        attr_accessor :development_settings_enabled
+        alias_method :development_settings_enabled?, :development_settings_enabled
+      
+        # Encryption status from DevicePolicyManager.
+        # Corresponds to the JSON property `encryptionStatus`
+        # @return [String]
+        attr_accessor :encryption_status
+      
+        # Whether the device is secured with PIN/password.
+        # Corresponds to the JSON property `isDeviceSecure`
+        # @return [Boolean]
+        attr_accessor :is_device_secure
+        alias_method :is_device_secure?, :is_device_secure
+      
+        # Whether the storage encryption is enabled.
+        # Corresponds to the JSON property `isEncrypted`
+        # @return [Boolean]
+        attr_accessor :is_encrypted
+        alias_method :is_encrypted?, :is_encrypted
+      
+        # Whether installing apps from unknown sources is enabled.
+        # Corresponds to the JSON property `unknownSourcesEnabled`
+        # @return [Boolean]
+        attr_accessor :unknown_sources_enabled
+        alias_method :unknown_sources_enabled?, :unknown_sources_enabled
+      
+        # Whether Verify Apps (Google Play Protect (https://support.google.com/
+        # googleplay/answer/2812853)) is enabled on the device.
+        # Corresponds to the JSON property `verifyAppsEnabled`
+        # @return [Boolean]
+        attr_accessor :verify_apps_enabled
+        alias_method :verify_apps_enabled?, :verify_apps_enabled
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @adb_enabled = args[:adb_enabled] if args.key?(:adb_enabled)
+          @development_settings_enabled = args[:development_settings_enabled] if args.key?(:development_settings_enabled)
+          @encryption_status = args[:encryption_status] if args.key?(:encryption_status)
+          @is_device_secure = args[:is_device_secure] if args.key?(:is_device_secure)
+          @is_encrypted = args[:is_encrypted] if args.key?(:is_encrypted)
+          @unknown_sources_enabled = args[:unknown_sources_enabled] if args.key?(:unknown_sources_enabled)
+          @verify_apps_enabled = args[:verify_apps_enabled] if args.key?(:verify_apps_enabled)
+        end
+      end
+      
+      # Device display information.
+      class DisplayProp
+        include Google::Apis::Core::Hashable
+      
+        # Display density expressed as dots-per-inch.
+        # Corresponds to the JSON property `density`
+        # @return [Fixnum]
+        attr_accessor :density
+      
+        # Unique display id.
+        # Corresponds to the JSON property `displayId`
+        # @return [Fixnum]
+        attr_accessor :display_id
+      
+        # Display height in pixels.
+        # Corresponds to the JSON property `height`
+        # @return [Fixnum]
+        attr_accessor :height
+      
+        # Name of the display.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Refresh rate of the display in frames per second.
+        # Corresponds to the JSON property `refreshRate`
+        # @return [Fixnum]
+        attr_accessor :refresh_rate
+      
+        # State of the display.
+        # Corresponds to the JSON property `state`
+        # @return [String]
+        attr_accessor :state
+      
+        # Display width in pixels.
+        # Corresponds to the JSON property `width`
+        # @return [Fixnum]
+        attr_accessor :width
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @density = args[:density] if args.key?(:density)
+          @display_id = args[:display_id] if args.key?(:display_id)
+          @height = args[:height] if args.key?(:height)
+          @name = args[:name] if args.key?(:name)
+          @refresh_rate = args[:refresh_rate] if args.key?(:refresh_rate)
+          @state = args[:state] if args.key?(:state)
+          @width = args[:width] if args.key?(:width)
+        end
+      end
+      
+      # A generic empty message that you can re-use to avoid defining duplicated empty
+      # messages in your APIs. A typical example is to use it as the request or the
+      # response type of an API method. For instance: service Foo ` rpc Bar(google.
+      # protobuf.Empty) returns (google.protobuf.Empty); ` The JSON representation for
+      # Empty is empty JSON object ``.
+      class Empty
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # An enrollment token.
+      class EnrollmentToken
+        include Google::Apis::Core::Hashable
+      
+        # Optional, arbitrary data associated with the enrollment token. This could
+        # contain, for example, the ID of an org unit the device is assigned to after
+        # enrollment. After a device enrolls with the token, this data will be exposed
+        # in the enrollment_token_data field of the Device resource. The data must be
+        # 1024 characters or less; otherwise, the creation request will fail.
+        # Corresponds to the JSON property `additionalData`
+        # @return [String]
+        attr_accessor :additional_data
+      
+        # Controls whether personal usage is allowed on a device provisioned with this
+        # enrollment token.For company-owned devices: Enabling personal usage allows the
+        # user to set up a work profile on the device. Disabling personal usage requires
+        # the user provision the device as a fully managed device.For personally-owned
+        # devices: Enabling personal usage allows the user to set up a work profile on
+        # the device. Disabling personal usage will prevent the device from provisioning.
+        # Personal usage cannot be disabled on personally-owned device.
+        # Corresponds to the JSON property `allowPersonalUsage`
+        # @return [String]
+        attr_accessor :allow_personal_usage
+      
+        # The length of time the enrollment token is valid, ranging from 1 minute to 30
+        # days. If not specified, the default duration is 1 hour.
+        # Corresponds to the JSON property `duration`
+        # @return [String]
+        attr_accessor :duration
+      
+        # The expiration time of the token. This is a read-only field generated by the
+        # server.
+        # Corresponds to the JSON property `expirationTimestamp`
+        # @return [String]
+        attr_accessor :expiration_timestamp
+      
+        # The name of the enrollment token, which is generated by the server during
+        # creation, in the form enterprises/`enterpriseId`/enrollmentTokens/`
+        # enrollmentTokenId`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Whether the enrollment token is for one time use only. If the flag is set to
+        # true, only one device can use it for registration.
+        # Corresponds to the JSON property `oneTimeOnly`
+        # @return [Boolean]
+        attr_accessor :one_time_only
+        alias_method :one_time_only?, :one_time_only
+      
+        # The name of the policy initially applied to the enrolled device, in the form
+        # enterprises/`enterpriseId`/policies/`policyId`. If not specified, the
+        # policy_name for the device’s user is applied. If user_name is also not
+        # specified, enterprises/`enterpriseId`/policies/default is applied by default.
+        # When updating this field, you can specify only the policyId as long as the
+        # policyId doesn’t contain any slashes. The rest of the policy name will be
+        # inferred.
+        # Corresponds to the JSON property `policyName`
+        # @return [String]
+        attr_accessor :policy_name
+      
+        # A JSON string whose UTF-8 representation can be used to generate a QR code to
+        # enroll a device with this enrollment token. To enroll a device using NFC, the
+        # NFC record must contain a serialized java.util.Properties representation of
+        # the properties in the JSON.
+        # Corresponds to the JSON property `qrCode`
+        # @return [String]
+        attr_accessor :qr_code
+      
+        # A user belonging to an enterprise.
+        # Corresponds to the JSON property `user`
+        # @return [Google::Apis::AndroidmanagementV1::User]
+        attr_accessor :user
+      
+        # The token value that's passed to the device and authorizes the device to
+        # enroll. This is a read-only field generated by the server.
+        # Corresponds to the JSON property `value`
+        # @return [String]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @additional_data = args[:additional_data] if args.key?(:additional_data)
+          @allow_personal_usage = args[:allow_personal_usage] if args.key?(:allow_personal_usage)
+          @duration = args[:duration] if args.key?(:duration)
+          @expiration_timestamp = args[:expiration_timestamp] if args.key?(:expiration_timestamp)
+          @name = args[:name] if args.key?(:name)
+          @one_time_only = args[:one_time_only] if args.key?(:one_time_only)
+          @policy_name = args[:policy_name] if args.key?(:policy_name)
+          @qr_code = args[:qr_code] if args.key?(:qr_code)
+          @user = args[:user] if args.key?(:user)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # The configuration applied to an enterprise.
+      class Enterprise
+        include Google::Apis::Core::Hashable
+      
+        # Deprecated and unused.
+        # Corresponds to the JSON property `appAutoApprovalEnabled`
+        # @return [Boolean]
+        attr_accessor :app_auto_approval_enabled
+        alias_method :app_auto_approval_enabled?, :app_auto_approval_enabled
+      
+        # The types of Google Pub/Sub notifications enabled for the enterprise.
+        # Corresponds to the JSON property `enabledNotificationTypes`
+        # @return [Array<String>]
+        attr_accessor :enabled_notification_types
+      
+        # The name of the enterprise displayed to users.
+        # Corresponds to the JSON property `enterpriseDisplayName`
+        # @return [String]
+        attr_accessor :enterprise_display_name
+      
+        # Data hosted at an external location. The data is to be downloaded by Android
+        # Device Policy and verified against the hash.
+        # Corresponds to the JSON property `logo`
+        # @return [Google::Apis::AndroidmanagementV1::ExternalData]
+        attr_accessor :logo
+      
+        # The name of the enterprise which is generated by the server during creation,
+        # in the form enterprises/`enterpriseId`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A color in RGB format that indicates the predominant color to display in the
+        # device management app UI. The color components are stored as follows: (red <<
+        # 16) | (green << 8) | blue, where the value of each component is between 0 and
+        # 255, inclusive.
+        # Corresponds to the JSON property `primaryColor`
+        # @return [Fixnum]
+        attr_accessor :primary_color
+      
+        # The topic that Cloud Pub/Sub notifications are published to, in the form
+        # projects/`project`/topics/`topic`. This field is only required if Pub/Sub
+        # notifications are enabled.
+        # Corresponds to the JSON property `pubsubTopic`
+        # @return [String]
+        attr_accessor :pubsub_topic
+      
+        # Sign-in details of the enterprise.
+        # Corresponds to the JSON property `signinDetails`
+        # @return [Array<Google::Apis::AndroidmanagementV1::SigninDetail>]
+        attr_accessor :signin_details
+      
+        # Terms and conditions that must be accepted when provisioning a device for this
+        # enterprise. A page of terms is generated for each value in this list.
+        # Corresponds to the JSON property `termsAndConditions`
+        # @return [Array<Google::Apis::AndroidmanagementV1::TermsAndConditions>]
+        attr_accessor :terms_and_conditions
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @app_auto_approval_enabled = args[:app_auto_approval_enabled] if args.key?(:app_auto_approval_enabled)
+          @enabled_notification_types = args[:enabled_notification_types] if args.key?(:enabled_notification_types)
+          @enterprise_display_name = args[:enterprise_display_name] if args.key?(:enterprise_display_name)
+          @logo = args[:logo] if args.key?(:logo)
+          @name = args[:name] if args.key?(:name)
+          @primary_color = args[:primary_color] if args.key?(:primary_color)
+          @pubsub_topic = args[:pubsub_topic] if args.key?(:pubsub_topic)
+          @signin_details = args[:signin_details] if args.key?(:signin_details)
+          @terms_and_conditions = args[:terms_and_conditions] if args.key?(:terms_and_conditions)
+        end
+      end
+      
+      # Data hosted at an external location. The data is to be downloaded by Android
+      # Device Policy and verified against the hash.
+      class ExternalData
+        include Google::Apis::Core::Hashable
+      
+        # The base-64 encoded SHA-256 hash of the content hosted at url. If the content
+        # doesn't match this hash, Android Device Policy won't use the data.
+        # Corresponds to the JSON property `sha256Hash`
+        # @return [String]
+        attr_accessor :sha256_hash
+      
+        # The absolute URL to the data, which must use either the http or https scheme.
+        # Android Device Policy doesn't provide any credentials in the GET request, so
+        # the URL must be publicly accessible. Including a long, random component in the
+        # URL may be used to prevent attackers from discovering the URL.
+        # Corresponds to the JSON property `url`
+        # @return [String]
+        attr_accessor :url
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @sha256_hash = args[:sha256_hash] if args.key?(:sha256_hash)
+          @url = args[:url] if args.key?(:url)
+        end
+      end
+      
+      # A system freeze period. When a device’s clock is within the freeze period, all
+      # incoming system updates (including security patches) are blocked and won’t be
+      # installed. When a device is outside the freeze period, normal update behavior
+      # applies. Leap years are ignored in freeze period calculations, in particular: *
+      # If Feb. 29th is set as the start or end date of a freeze period, the freeze
+      # period will start or end on Feb. 28th instead. * When a device’s system clock
+      # reads Feb. 29th, it’s treated as Feb. 28th. * When calculating the number of
+      # days in a freeze period or the time between two freeze periods, Feb. 29th is
+      # ignored and not counted as a day.
+      class FreezePeriod
+        include Google::Apis::Core::Hashable
+      
+        # Represents a whole or partial calendar date, such as a birthday. The time of
+        # day and time zone are either specified elsewhere or are insignificant. The
+        # date is relative to the Gregorian Calendar. This can represent one of the
+        # following: A full date, with non-zero year, month, and day values A month and
+        # day value, with a zero year, such as an anniversary A year on its own, with
+        # zero month and day values A year and month value, with a zero day, such as a
+        # credit card expiration dateRelated types are google.type.TimeOfDay and google.
+        # protobuf.Timestamp.
+        # Corresponds to the JSON property `endDate`
+        # @return [Google::Apis::AndroidmanagementV1::Date]
+        attr_accessor :end_date
+      
+        # Represents a whole or partial calendar date, such as a birthday. The time of
+        # day and time zone are either specified elsewhere or are insignificant. The
+        # date is relative to the Gregorian Calendar. This can represent one of the
+        # following: A full date, with non-zero year, month, and day values A month and
+        # day value, with a zero year, such as an anniversary A year on its own, with
+        # zero month and day values A year and month value, with a zero day, such as a
+        # credit card expiration dateRelated types are google.type.TimeOfDay and google.
+        # protobuf.Timestamp.
+        # Corresponds to the JSON property `startDate`
+        # @return [Google::Apis::AndroidmanagementV1::Date]
+        attr_accessor :start_date
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @end_date = args[:end_date] if args.key?(:end_date)
+          @start_date = args[:start_date] if args.key?(:start_date)
+        end
+      end
+      
+      # Information about device hardware. The fields related to temperature
+      # thresholds are only available if hardwareStatusEnabled is true in the device's
+      # policy.
+      class HardwareInfo
+        include Google::Apis::Core::Hashable
+      
+        # Battery shutdown temperature thresholds in Celsius for each battery on the
+        # device.
+        # Corresponds to the JSON property `batteryShutdownTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :battery_shutdown_temperatures
+      
+        # Battery throttling temperature thresholds in Celsius for each battery on the
+        # device.
+        # Corresponds to the JSON property `batteryThrottlingTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :battery_throttling_temperatures
+      
+        # Brand of the device. For example, Google.
+        # Corresponds to the JSON property `brand`
+        # @return [String]
+        attr_accessor :brand
+      
+        # CPU shutdown temperature thresholds in Celsius for each CPU on the device.
+        # Corresponds to the JSON property `cpuShutdownTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :cpu_shutdown_temperatures
+      
+        # CPU throttling temperature thresholds in Celsius for each CPU on the device.
+        # Corresponds to the JSON property `cpuThrottlingTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :cpu_throttling_temperatures
+      
+        # Baseband version. For example, MDM9625_104662.22.05.34p.
+        # Corresponds to the JSON property `deviceBasebandVersion`
+        # @return [String]
+        attr_accessor :device_baseband_version
+      
+        # GPU shutdown temperature thresholds in Celsius for each GPU on the device.
+        # Corresponds to the JSON property `gpuShutdownTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :gpu_shutdown_temperatures
+      
+        # GPU throttling temperature thresholds in Celsius for each GPU on the device.
+        # Corresponds to the JSON property `gpuThrottlingTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :gpu_throttling_temperatures
+      
+        # Name of the hardware. For example, Angler.
+        # Corresponds to the JSON property `hardware`
+        # @return [String]
+        attr_accessor :hardware
+      
+        # Manufacturer. For example, Motorola.
+        # Corresponds to the JSON property `manufacturer`
+        # @return [String]
+        attr_accessor :manufacturer
+      
+        # The model of the device. For example, Asus Nexus 7.
+        # Corresponds to the JSON property `model`
+        # @return [String]
+        attr_accessor :model
+      
+        # The device serial number.
+        # Corresponds to the JSON property `serialNumber`
+        # @return [String]
+        attr_accessor :serial_number
+      
+        # Device skin shutdown temperature thresholds in Celsius.
+        # Corresponds to the JSON property `skinShutdownTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :skin_shutdown_temperatures
+      
+        # Device skin throttling temperature thresholds in Celsius.
+        # Corresponds to the JSON property `skinThrottlingTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :skin_throttling_temperatures
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @battery_shutdown_temperatures = args[:battery_shutdown_temperatures] if args.key?(:battery_shutdown_temperatures)
+          @battery_throttling_temperatures = args[:battery_throttling_temperatures] if args.key?(:battery_throttling_temperatures)
+          @brand = args[:brand] if args.key?(:brand)
+          @cpu_shutdown_temperatures = args[:cpu_shutdown_temperatures] if args.key?(:cpu_shutdown_temperatures)
+          @cpu_throttling_temperatures = args[:cpu_throttling_temperatures] if args.key?(:cpu_throttling_temperatures)
+          @device_baseband_version = args[:device_baseband_version] if args.key?(:device_baseband_version)
+          @gpu_shutdown_temperatures = args[:gpu_shutdown_temperatures] if args.key?(:gpu_shutdown_temperatures)
+          @gpu_throttling_temperatures = args[:gpu_throttling_temperatures] if args.key?(:gpu_throttling_temperatures)
+          @hardware = args[:hardware] if args.key?(:hardware)
+          @manufacturer = args[:manufacturer] if args.key?(:manufacturer)
+          @model = args[:model] if args.key?(:model)
+          @serial_number = args[:serial_number] if args.key?(:serial_number)
+          @skin_shutdown_temperatures = args[:skin_shutdown_temperatures] if args.key?(:skin_shutdown_temperatures)
+          @skin_throttling_temperatures = args[:skin_throttling_temperatures] if args.key?(:skin_throttling_temperatures)
+        end
+      end
+      
+      # Hardware status. Temperatures may be compared to the temperature thresholds
+      # available in hardwareInfo to determine hardware health.
+      class HardwareStatus
+        include Google::Apis::Core::Hashable
+      
+        # Current battery temperatures in Celsius for each battery on the device.
+        # Corresponds to the JSON property `batteryTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :battery_temperatures
+      
+        # Current CPU temperatures in Celsius for each CPU on the device.
+        # Corresponds to the JSON property `cpuTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :cpu_temperatures
+      
+        # CPU usages in percentage for each core available on the device. Usage is 0 for
+        # each unplugged core. Empty array implies that CPU usage is not supported in
+        # the system.
+        # Corresponds to the JSON property `cpuUsages`
+        # @return [Array<Float>]
+        attr_accessor :cpu_usages
+      
+        # The time the measurements were taken.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # Fan speeds in RPM for each fan on the device. Empty array means that there are
+        # no fans or fan speed is not supported on the system.
+        # Corresponds to the JSON property `fanSpeeds`
+        # @return [Array<Float>]
+        attr_accessor :fan_speeds
+      
+        # Current GPU temperatures in Celsius for each GPU on the device.
+        # Corresponds to the JSON property `gpuTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :gpu_temperatures
+      
+        # Current device skin temperatures in Celsius.
+        # Corresponds to the JSON property `skinTemperatures`
+        # @return [Array<Float>]
+        attr_accessor :skin_temperatures
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @battery_temperatures = args[:battery_temperatures] if args.key?(:battery_temperatures)
+          @cpu_temperatures = args[:cpu_temperatures] if args.key?(:cpu_temperatures)
+          @cpu_usages = args[:cpu_usages] if args.key?(:cpu_usages)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @fan_speeds = args[:fan_speeds] if args.key?(:fan_speeds)
+          @gpu_temperatures = args[:gpu_temperatures] if args.key?(:gpu_temperatures)
+          @skin_temperatures = args[:skin_temperatures] if args.key?(:skin_temperatures)
+        end
+      end
+      
+      # Keyed app state reported by the app.
+      class KeyedAppState
+        include Google::Apis::Core::Hashable
+      
+        # The creation time of the app state on the device.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # Optionally, a machine-readable value to be read by the EMM. For example,
+        # setting values that the admin can choose to query against in the EMM console (
+        # e.g. “notify me if the battery_warning data < 10”).
+        # Corresponds to the JSON property `data`
+        # @return [String]
+        attr_accessor :data
+      
+        # The key for the app state. Acts as a point of reference for what the app is
+        # providing state for. For example, when providing managed configuration
+        # feedback, this key could be the managed configuration key.
+        # Corresponds to the JSON property `key`
+        # @return [String]
+        attr_accessor :key
+      
+        # The time the app state was most recently updated.
+        # Corresponds to the JSON property `lastUpdateTime`
+        # @return [String]
+        attr_accessor :last_update_time
+      
+        # Optionally, a free-form message string to explain the app state. If the state
+        # was triggered by a particular value (e.g. a managed configuration value), it
+        # should be included in the message.
+        # Corresponds to the JSON property `message`
+        # @return [String]
+        attr_accessor :message
+      
+        # The severity of the app state.
+        # Corresponds to the JSON property `severity`
+        # @return [String]
+        attr_accessor :severity
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @data = args[:data] if args.key?(:data)
+          @key = args[:key] if args.key?(:key)
+          @last_update_time = args[:last_update_time] if args.key?(:last_update_time)
+          @message = args[:message] if args.key?(:message)
+          @severity = args[:severity] if args.key?(:severity)
+        end
+      end
+      
+      # Settings controlling the behavior of a device in kiosk mode. To enable kiosk
+      # mode, set kioskCustomLauncherEnabled to true or specify an app in the policy
+      # with installType KIOSK.
+      class KioskCustomization
+        include Google::Apis::Core::Hashable
+      
+        # Specifies whether the Settings app is allowed in kiosk mode.
+        # Corresponds to the JSON property `deviceSettings`
+        # @return [String]
+        attr_accessor :device_settings
+      
+        # Sets the behavior of a device in kiosk mode when a user presses and holds (
+        # long-presses) the Power button.
+        # Corresponds to the JSON property `powerButtonActions`
+        # @return [String]
+        attr_accessor :power_button_actions
+      
+        # Specifies whether system info and notifications are disabled in kiosk mode.
+        # Corresponds to the JSON property `statusBar`
+        # @return [String]
+        attr_accessor :status_bar
+      
+        # Specifies whether system error dialogs for crashed or unresponsive apps are
+        # blocked in kiosk mode. When blocked, the system will force-stop the app as if
+        # the user chooses the "close app" option on the UI.
+        # Corresponds to the JSON property `systemErrorWarnings`
+        # @return [String]
+        attr_accessor :system_error_warnings
+      
+        # Specifies which navigation features are enabled (e.g. Home, Overview buttons)
+        # in kiosk mode.
+        # Corresponds to the JSON property `systemNavigation`
+        # @return [String]
+        attr_accessor :system_navigation
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @device_settings = args[:device_settings] if args.key?(:device_settings)
+          @power_button_actions = args[:power_button_actions] if args.key?(:power_button_actions)
+          @status_bar = args[:status_bar] if args.key?(:status_bar)
+          @system_error_warnings = args[:system_error_warnings] if args.key?(:system_error_warnings)
+          @system_navigation = args[:system_navigation] if args.key?(:system_navigation)
+        end
+      end
+      
+      # An action to launch an app.
+      class LaunchAppAction
+        include Google::Apis::Core::Hashable
+      
+        # Package name of app to be launched
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @package_name = args[:package_name] if args.key?(:package_name)
+        end
+      end
+      
+      # Response to a request to list devices for a given enterprise.
+      class ListDevicesResponse
+        include Google::Apis::Core::Hashable
+      
+        # The list of devices.
+        # Corresponds to the JSON property `devices`
+        # @return [Array<Google::Apis::AndroidmanagementV1::Device>]
+        attr_accessor :devices
+      
+        # If there are more results, a token to retrieve 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)
+          @devices = args[:devices] if args.key?(:devices)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # The response message for Operations.ListOperations.
+      class ListOperationsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The standard List next-page token.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # A list of operations that matches the specified filter in the request.
+        # Corresponds to the JSON property `operations`
+        # @return [Array<Google::Apis::AndroidmanagementV1::Operation>]
+        attr_accessor :operations
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @operations = args[:operations] if args.key?(:operations)
+        end
+      end
+      
+      # Response to a request to list policies for a given enterprise.
+      class ListPoliciesResponse
+        include Google::Apis::Core::Hashable
+      
+        # If there are more results, a token to retrieve next page of results.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # The list of policies.
+        # Corresponds to the JSON property `policies`
+        # @return [Array<Google::Apis::AndroidmanagementV1::Policy>]
+        attr_accessor :policies
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @policies = args[:policies] if args.key?(:policies)
+        end
+      end
+      
+      # Response to a request to list web apps for a given enterprise.
+      class ListWebAppsResponse
+        include Google::Apis::Core::Hashable
+      
+        # If there are more results, a token to retrieve next page of results.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        # The list of web apps.
+        # Corresponds to the JSON property `webApps`
+        # @return [Array<Google::Apis::AndroidmanagementV1::WebApp>]
+        attr_accessor :web_apps
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+          @web_apps = args[:web_apps] if args.key?(:web_apps)
+        end
+      end
+      
+      # The managed configurations template for the app, saved from the managed
+      # configurations iframe.
+      class ManagedConfigurationTemplate
+        include Google::Apis::Core::Hashable
+      
+        # Optional, a map containing configuration variables defined for the
+        # configuration.
+        # Corresponds to the JSON property `configurationVariables`
+        # @return [Hash<String,String>]
+        attr_accessor :configuration_variables
+      
+        # The ID of the managed configurations template.
+        # Corresponds to the JSON property `templateId`
+        # @return [String]
+        attr_accessor :template_id
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @configuration_variables = args[:configuration_variables] if args.key?(:configuration_variables)
+          @template_id = args[:template_id] if args.key?(:template_id)
+        end
+      end
+      
+      # Managed property.
+      class ManagedProperty
+        include Google::Apis::Core::Hashable
+      
+        # The default value of the property. BUNDLE_ARRAY properties don't have a
+        # default value.
+        # Corresponds to the JSON property `defaultValue`
+        # @return [Object]
+        attr_accessor :default_value
+      
+        # A longer description of the property, providing more detail of what it affects.
+        # Localized.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # For CHOICE or MULTISELECT properties, the list of possible entries.
+        # Corresponds to the JSON property `entries`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ManagedPropertyEntry>]
+        attr_accessor :entries
+      
+        # The unique key that the app uses to identify the property, e.g. "com.google.
+        # android.gm.fieldname".
+        # Corresponds to the JSON property `key`
+        # @return [String]
+        attr_accessor :key
+      
+        # For BUNDLE_ARRAY properties, the list of nested properties. A BUNDLE_ARRAY
+        # property is at most two levels deep.
+        # Corresponds to the JSON property `nestedProperties`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ManagedProperty>]
+        attr_accessor :nested_properties
+      
+        # The name of the property. Localized.
+        # Corresponds to the JSON property `title`
+        # @return [String]
+        attr_accessor :title
+      
+        # The type of the property.
+        # 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)
+          @default_value = args[:default_value] if args.key?(:default_value)
+          @description = args[:description] if args.key?(:description)
+          @entries = args[:entries] if args.key?(:entries)
+          @key = args[:key] if args.key?(:key)
+          @nested_properties = args[:nested_properties] if args.key?(:nested_properties)
+          @title = args[:title] if args.key?(:title)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # An entry of a managed property.
+      class ManagedPropertyEntry
+        include Google::Apis::Core::Hashable
+      
+        # The human-readable name of the value. Localized.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The machine-readable value of the entry, which should be used in the
+        # configuration. Not localized.
+        # Corresponds to the JSON property `value`
+        # @return [String]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @name = args[:name] if args.key?(:name)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # An event related to memory and storage measurements.
+      class MemoryEvent
+        include Google::Apis::Core::Hashable
+      
+        # The number of free bytes in the medium, or for EXTERNAL_STORAGE_DETECTED, the
+        # total capacity in bytes of the storage medium.
+        # Corresponds to the JSON property `byteCount`
+        # @return [Fixnum]
+        attr_accessor :byte_count
+      
+        # The creation time of the event.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # Event type.
+        # Corresponds to the JSON property `eventType`
+        # @return [String]
+        attr_accessor :event_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @byte_count = args[:byte_count] if args.key?(:byte_count)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @event_type = args[:event_type] if args.key?(:event_type)
+        end
+      end
+      
+      # Information about device memory and storage.
+      class MemoryInfo
+        include Google::Apis::Core::Hashable
+      
+        # Total internal storage on device in bytes.
+        # Corresponds to the JSON property `totalInternalStorage`
+        # @return [Fixnum]
+        attr_accessor :total_internal_storage
+      
+        # Total RAM on device in bytes.
+        # Corresponds to the JSON property `totalRam`
+        # @return [Fixnum]
+        attr_accessor :total_ram
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @total_internal_storage = args[:total_internal_storage] if args.key?(:total_internal_storage)
+          @total_ram = args[:total_ram] if args.key?(:total_ram)
+        end
+      end
+      
+      # Device network info.
+      class NetworkInfo
+        include Google::Apis::Core::Hashable
+      
+        # IMEI number of the GSM device. For example, A1000031212.
+        # Corresponds to the JSON property `imei`
+        # @return [String]
+        attr_accessor :imei
+      
+        # MEID number of the CDMA device. For example, A00000292788E1.
+        # Corresponds to the JSON property `meid`
+        # @return [String]
+        attr_accessor :meid
+      
+        # Alphabetic name of current registered operator. For example, Vodafone.
+        # Corresponds to the JSON property `networkOperatorName`
+        # @return [String]
+        attr_accessor :network_operator_name
+      
+        # Wi-Fi MAC address of the device. For example, 7c:11:11:11:11:11.
+        # Corresponds to the JSON property `wifiMacAddress`
+        # @return [String]
+        attr_accessor :wifi_mac_address
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @imei = args[:imei] if args.key?(:imei)
+          @meid = args[:meid] if args.key?(:meid)
+          @network_operator_name = args[:network_operator_name] if args.key?(:network_operator_name)
+          @wifi_mac_address = args[:wifi_mac_address] if args.key?(:wifi_mac_address)
+        end
+      end
+      
+      # Provides detail about non-compliance with a policy setting.
+      class NonComplianceDetail
+        include Google::Apis::Core::Hashable
+      
+        # If the policy setting could not be applied, the current value of the setting
+        # on the device.
+        # Corresponds to the JSON property `currentValue`
+        # @return [Object]
+        attr_accessor :current_value
+      
+        # For settings with nested fields, if a particular nested field is out of
+        # compliance, this specifies the full path to the offending field. The path is
+        # formatted in the same way the policy JSON field would be referenced in
+        # JavaScript, that is: 1) For object-typed fields, the field name is followed by
+        # a dot then by a subfield name. 2) For array-typed fields, the field name is
+        # followed by the array index enclosed in brackets. For example, to indicate a
+        # problem with the url field in the externalData field in the 3rd application,
+        # the path would be applications[2].externalData.url
+        # Corresponds to the JSON property `fieldPath`
+        # @return [String]
+        attr_accessor :field_path
+      
+        # If package_name is set and the non-compliance reason is APP_NOT_INSTALLED or
+        # APP_NOT_UPDATED, the detailed reason the app can't be installed or updated.
+        # Corresponds to the JSON property `installationFailureReason`
+        # @return [String]
+        attr_accessor :installation_failure_reason
+      
+        # The reason the device is not in compliance with the setting.
+        # Corresponds to the JSON property `nonComplianceReason`
+        # @return [String]
+        attr_accessor :non_compliance_reason
+      
+        # The package name indicating which app is out of compliance, if applicable.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        # The name of the policy setting. This is the JSON field name of a top-level
+        # Policy field.
+        # Corresponds to the JSON property `settingName`
+        # @return [String]
+        attr_accessor :setting_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @current_value = args[:current_value] if args.key?(:current_value)
+          @field_path = args[:field_path] if args.key?(:field_path)
+          @installation_failure_reason = args[:installation_failure_reason] if args.key?(:installation_failure_reason)
+          @non_compliance_reason = args[:non_compliance_reason] if args.key?(:non_compliance_reason)
+          @package_name = args[:package_name] if args.key?(:package_name)
+          @setting_name = args[:setting_name] if args.key?(:setting_name)
+        end
+      end
+      
+      # A compliance rule condition which is satisfied if there exists any matching
+      # NonComplianceDetail for the device. A NonComplianceDetail matches a
+      # NonComplianceDetailCondition if all the fields which are set within the
+      # NonComplianceDetailCondition match the corresponding NonComplianceDetail
+      # fields.
+      class NonComplianceDetailCondition
+        include Google::Apis::Core::Hashable
+      
+        # The reason the device is not in compliance with the setting. If not set, then
+        # this condition matches any reason.
+        # Corresponds to the JSON property `nonComplianceReason`
+        # @return [String]
+        attr_accessor :non_compliance_reason
+      
+        # The package name of the app that's out of compliance. If not set, then this
+        # condition matches any package name.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        # The name of the policy setting. This is the JSON field name of a top-level
+        # Policy field. If not set, then this condition matches any setting name.
+        # Corresponds to the JSON property `settingName`
+        # @return [String]
+        attr_accessor :setting_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @non_compliance_reason = args[:non_compliance_reason] if args.key?(:non_compliance_reason)
+          @package_name = args[:package_name] if args.key?(:package_name)
+          @setting_name = args[:setting_name] if args.key?(:setting_name)
+        end
+      end
+      
+      # This resource represents a long-running operation that is the result of a
+      # network API call.
+      class Operation
+        include Google::Apis::Core::Hashable
+      
+        # If the value is false, it means the operation is still in progress. If true,
+        # the operation is completed, and either error or response is available.
+        # Corresponds to the JSON property `done`
+        # @return [Boolean]
+        attr_accessor :done
+        alias_method :done?, :done
+      
+        # The Status type defines a logical error model that is suitable for different
+        # programming environments, including REST APIs and RPC APIs. It is used by gRPC
+        # (https://github.com/grpc). Each Status message contains three pieces of data:
+        # error code, error message, and error details.You can find out more about this
+        # error model and how to work with it in the API Design Guide (https://cloud.
+        # google.com/apis/design/errors).
+        # Corresponds to the JSON property `error`
+        # @return [Google::Apis::AndroidmanagementV1::Status]
+        attr_accessor :error
+      
+        # Service-specific metadata associated with the operation. It typically contains
+        # progress information and common metadata such as create time. Some services
+        # might not provide such metadata. Any method that returns a long-running
+        # operation should document the metadata type, if any.
+        # Corresponds to the JSON property `metadata`
+        # @return [Hash<String,Object>]
+        attr_accessor :metadata
+      
+        # The server-assigned name, which is only unique within the same service that
+        # originally returns it. If you use the default HTTP mapping, the name should be
+        # a resource name ending with operations/`unique_id`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The normal response of the operation in case of success. If the original
+        # method returns no data on success, such as Delete, the response is google.
+        # protobuf.Empty. If the original method is standard Get/Create/Update, the
+        # response should be the resource. For other methods, the response should have
+        # the type XxxResponse, where Xxx is the original method name. For example, if
+        # the original method name is TakeSnapshot(), the inferred response type is
+        # TakeSnapshotResponse.
+        # Corresponds to the JSON property `response`
+        # @return [Hash<String,Object>]
+        attr_accessor :response
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @done = args[:done] if args.key?(:done)
+          @error = args[:error] if args.key?(:error)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @name = args[:name] if args.key?(:name)
+          @response = args[:response] if args.key?(:response)
+        end
+      end
+      
+      # A list of package names.
+      class PackageNameList
+        include Google::Apis::Core::Hashable
+      
+        # A list of package names.
+        # Corresponds to the JSON property `packageNames`
+        # @return [Array<String>]
+        attr_accessor :package_names
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @package_names = args[:package_names] if args.key?(:package_names)
+        end
+      end
+      
+      # Requirements for the password used to unlock a device.
+      class PasswordRequirements
+        include Google::Apis::Core::Hashable
+      
+        # Number of incorrect device-unlock passwords that can be entered before a
+        # device is wiped. A value of 0 means there is no restriction.
+        # Corresponds to the JSON property `maximumFailedPasswordsForWipe`
+        # @return [Fixnum]
+        attr_accessor :maximum_failed_passwords_for_wipe
+      
+        # Password expiration timeout.
+        # Corresponds to the JSON property `passwordExpirationTimeout`
+        # @return [String]
+        attr_accessor :password_expiration_timeout
+      
+        # The length of the password history. After setting this field, the user won't
+        # be able to enter a new password that is the same as any password in the
+        # history. A value of 0 means there is no restriction.
+        # Corresponds to the JSON property `passwordHistoryLength`
+        # @return [Fixnum]
+        attr_accessor :password_history_length
+      
+        # The minimum allowed password length. A value of 0 means there is no
+        # restriction. Only enforced when password_quality is NUMERIC, NUMERIC_COMPLEX,
+        # ALPHABETIC, ALPHANUMERIC, or COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumLength`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_length
+      
+        # Minimum number of letters required in the password. Only enforced when
+        # password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumLetters`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_letters
+      
+        # Minimum number of lower case letters required in the password. Only enforced
+        # when password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumLowerCase`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_lower_case
+      
+        # Minimum number of non-letter characters (numerical digits or symbols) required
+        # in the password. Only enforced when password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumNonLetter`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_non_letter
+      
+        # Minimum number of numerical digits required in the password. Only enforced
+        # when password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumNumeric`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_numeric
+      
+        # Minimum number of symbols required in the password. Only enforced when
+        # password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumSymbols`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_symbols
+      
+        # Minimum number of upper case letters required in the password. Only enforced
+        # when password_quality is COMPLEX.
+        # Corresponds to the JSON property `passwordMinimumUpperCase`
+        # @return [Fixnum]
+        attr_accessor :password_minimum_upper_case
+      
+        # The required password quality.
+        # Corresponds to the JSON property `passwordQuality`
+        # @return [String]
+        attr_accessor :password_quality
+      
+        # The scope that the password requirement applies to.
+        # Corresponds to the JSON property `passwordScope`
+        # @return [String]
+        attr_accessor :password_scope
+      
+        # The length of time after a device or work profile is unlocked using a strong
+        # form of authentication (password, PIN, pattern) that it can be unlocked using
+        # any other authentication method (e.g. fingerprint, trust agents, face). After
+        # the specified time period elapses, only strong forms of authentication can be
+        # used to unlock the device or work profile.
+        # Corresponds to the JSON property `requirePasswordUnlock`
+        # @return [String]
+        attr_accessor :require_password_unlock
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @maximum_failed_passwords_for_wipe = args[:maximum_failed_passwords_for_wipe] if args.key?(:maximum_failed_passwords_for_wipe)
+          @password_expiration_timeout = args[:password_expiration_timeout] if args.key?(:password_expiration_timeout)
+          @password_history_length = args[:password_history_length] if args.key?(:password_history_length)
+          @password_minimum_length = args[:password_minimum_length] if args.key?(:password_minimum_length)
+          @password_minimum_letters = args[:password_minimum_letters] if args.key?(:password_minimum_letters)
+          @password_minimum_lower_case = args[:password_minimum_lower_case] if args.key?(:password_minimum_lower_case)
+          @password_minimum_non_letter = args[:password_minimum_non_letter] if args.key?(:password_minimum_non_letter)
+          @password_minimum_numeric = args[:password_minimum_numeric] if args.key?(:password_minimum_numeric)
+          @password_minimum_symbols = args[:password_minimum_symbols] if args.key?(:password_minimum_symbols)
+          @password_minimum_upper_case = args[:password_minimum_upper_case] if args.key?(:password_minimum_upper_case)
+          @password_quality = args[:password_quality] if args.key?(:password_quality)
+          @password_scope = args[:password_scope] if args.key?(:password_scope)
+          @require_password_unlock = args[:require_password_unlock] if args.key?(:require_password_unlock)
+        end
+      end
+      
+      # Configuration for an Android permission and its grant state.
+      class PermissionGrant
+        include Google::Apis::Core::Hashable
+      
+        # The Android permission or group, e.g. android.permission.READ_CALENDAR or
+        # android.permission_group.CALENDAR.
+        # Corresponds to the JSON property `permission`
+        # @return [String]
+        attr_accessor :permission
+      
+        # The policy for granting the permission.
+        # Corresponds to the JSON property `policy`
+        # @return [String]
+        attr_accessor :policy
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @permission = args[:permission] if args.key?(:permission)
+          @policy = args[:policy] if args.key?(:policy)
+        end
+      end
+      
+      # A default activity for handling intents that match a particular intent filter.
+      # Note: To set up a kiosk, use InstallType to KIOSK rather than use persistent
+      # preferred activities.
+      class PersistentPreferredActivity
+        include Google::Apis::Core::Hashable
+      
+        # The intent actions to match in the filter. If any actions are included in the
+        # filter, then an intent's action must be one of those values for it to match.
+        # If no actions are included, the intent action is ignored.
+        # Corresponds to the JSON property `actions`
+        # @return [Array<String>]
+        attr_accessor :actions
+      
+        # The intent categories to match in the filter. An intent includes the
+        # categories that it requires, all of which must be included in the filter in
+        # order to match. In other words, adding a category to the filter has no impact
+        # on matching unless that category is specified in the intent.
+        # Corresponds to the JSON property `categories`
+        # @return [Array<String>]
+        attr_accessor :categories
+      
+        # The activity that should be the default intent handler. This should be an
+        # Android component name, e.g. com.android.enterprise.app/.MainActivity.
+        # Alternatively, the value may be the package name of an app, which causes
+        # Android Device Policy to choose an appropriate activity from the app to handle
+        # the intent.
+        # Corresponds to the JSON property `receiverActivity`
+        # @return [String]
+        attr_accessor :receiver_activity
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @actions = args[:actions] if args.key?(:actions)
+          @categories = args[:categories] if args.key?(:categories)
+          @receiver_activity = args[:receiver_activity] if args.key?(:receiver_activity)
+        end
+      end
+      
+      # Policies for apps in the personal profile of a company-owned device with a
+      # work profile.
+      class PersonalApplicationPolicy
+        include Google::Apis::Core::Hashable
+      
+        # The type of installation to perform.
+        # Corresponds to the JSON property `installType`
+        # @return [String]
+        attr_accessor :install_type
+      
+        # The package name of the application.
+        # Corresponds to the JSON property `packageName`
+        # @return [String]
+        attr_accessor :package_name
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @install_type = args[:install_type] if args.key?(:install_type)
+          @package_name = args[:package_name] if args.key?(:package_name)
+        end
+      end
+      
+      # Policies controlling personal usage on a company-owned device with a work
+      # profile.
+      class PersonalUsagePolicies
+        include Google::Apis::Core::Hashable
+      
+        # Account types that can't be managed by the user.
+        # Corresponds to the JSON property `accountTypesWithManagementDisabled`
+        # @return [Array<String>]
+        attr_accessor :account_types_with_management_disabled
+      
+        # Whether camera is disabled.
+        # Corresponds to the JSON property `cameraDisabled`
+        # @return [Boolean]
+        attr_accessor :camera_disabled
+        alias_method :camera_disabled?, :camera_disabled
+      
+        # Controls how long the work profile can stay off.
+        # Corresponds to the JSON property `maxDaysWithWorkOff`
+        # @return [Fixnum]
+        attr_accessor :max_days_with_work_off
+      
+        # Policy applied to applications in the personal profile.
+        # Corresponds to the JSON property `personalApplications`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PersonalApplicationPolicy>]
+        attr_accessor :personal_applications
+      
+        # Used together with personalApplications to control how apps in the personal
+        # profile are allowed or blocked.
+        # Corresponds to the JSON property `personalPlayStoreMode`
+        # @return [String]
+        attr_accessor :personal_play_store_mode
+      
+        # Whether screen capture is disabled.
+        # Corresponds to the JSON property `screenCaptureDisabled`
+        # @return [Boolean]
+        attr_accessor :screen_capture_disabled
+        alias_method :screen_capture_disabled?, :screen_capture_disabled
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @account_types_with_management_disabled = args[:account_types_with_management_disabled] if args.key?(:account_types_with_management_disabled)
+          @camera_disabled = args[:camera_disabled] if args.key?(:camera_disabled)
+          @max_days_with_work_off = args[:max_days_with_work_off] if args.key?(:max_days_with_work_off)
+          @personal_applications = args[:personal_applications] if args.key?(:personal_applications)
+          @personal_play_store_mode = args[:personal_play_store_mode] if args.key?(:personal_play_store_mode)
+          @screen_capture_disabled = args[:screen_capture_disabled] if args.key?(:screen_capture_disabled)
+        end
+      end
+      
+      # A policy resource represents a group of settings that govern the behavior of a
+      # managed device and the apps installed on it.
+      class Policy
+        include Google::Apis::Core::Hashable
+      
+        # Account types that can't be managed by the user.
+        # Corresponds to the JSON property `accountTypesWithManagementDisabled`
+        # @return [Array<String>]
+        attr_accessor :account_types_with_management_disabled
+      
+        # Whether adding new users and profiles is disabled.
+        # Corresponds to the JSON property `addUserDisabled`
+        # @return [Boolean]
+        attr_accessor :add_user_disabled
+        alias_method :add_user_disabled?, :add_user_disabled
+      
+        # Whether adjusting the master volume is disabled.
+        # Corresponds to the JSON property `adjustVolumeDisabled`
+        # @return [Boolean]
+        attr_accessor :adjust_volume_disabled
+        alias_method :adjust_volume_disabled?, :adjust_volume_disabled
+      
+        # Security policies set to the most secure values by default. To maintain the
+        # security posture of a device, we don't recommend overriding any of the default
+        # values.
+        # Corresponds to the JSON property `advancedSecurityOverrides`
+        # @return [Google::Apis::AndroidmanagementV1::AdvancedSecurityOverrides]
+        attr_accessor :advanced_security_overrides
+      
+        # Configuration for an always-on VPN connection.
+        # Corresponds to the JSON property `alwaysOnVpnPackage`
+        # @return [Google::Apis::AndroidmanagementV1::AlwaysOnVpnPackage]
+        attr_accessor :always_on_vpn_package
+      
+        # The app tracks for Android Device Policy the device can access. The device
+        # receives the latest version among all accessible tracks. If no tracks are
+        # specified, then the device only uses the production track.
+        # Corresponds to the JSON property `androidDevicePolicyTracks`
+        # @return [Array<String>]
+        attr_accessor :android_device_policy_tracks
+      
+        # The app auto update policy, which controls when automatic app updates can be
+        # applied.
+        # Corresponds to the JSON property `appAutoUpdatePolicy`
+        # @return [String]
+        attr_accessor :app_auto_update_policy
+      
+        # Policy applied to apps.
+        # Corresponds to the JSON property `applications`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ApplicationPolicy>]
+        attr_accessor :applications
+      
+        # Whether auto date, time, and time zone are enabled on a company-owned device.
+        # If this is set, then autoTimeRequired is ignored.
+        # Corresponds to the JSON property `autoDateAndTimeZone`
+        # @return [String]
+        attr_accessor :auto_date_and_time_zone
+      
+        # Whether auto time is required, which prevents the user from manually setting
+        # the date and time. If autoDateAndTimeZone is set, this field is ignored.
+        # Corresponds to the JSON property `autoTimeRequired`
+        # @return [Boolean]
+        attr_accessor :auto_time_required
+        alias_method :auto_time_required?, :auto_time_required
+      
+        # Whether applications other than the ones configured in applications are
+        # blocked from being installed. When set, applications that were installed under
+        # a previous policy but no longer appear in the policy are automatically
+        # uninstalled.
+        # Corresponds to the JSON property `blockApplicationsEnabled`
+        # @return [Boolean]
+        attr_accessor :block_applications_enabled
+        alias_method :block_applications_enabled?, :block_applications_enabled
+      
+        # Whether configuring bluetooth is disabled.
+        # Corresponds to the JSON property `bluetoothConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :bluetooth_config_disabled
+        alias_method :bluetooth_config_disabled?, :bluetooth_config_disabled
+      
+        # Whether bluetooth contact sharing is disabled.
+        # Corresponds to the JSON property `bluetoothContactSharingDisabled`
+        # @return [Boolean]
+        attr_accessor :bluetooth_contact_sharing_disabled
+        alias_method :bluetooth_contact_sharing_disabled?, :bluetooth_contact_sharing_disabled
+      
+        # Whether bluetooth is disabled. Prefer this setting over
+        # bluetooth_config_disabled because bluetooth_config_disabled can be bypassed by
+        # the user.
+        # Corresponds to the JSON property `bluetoothDisabled`
+        # @return [Boolean]
+        attr_accessor :bluetooth_disabled
+        alias_method :bluetooth_disabled?, :bluetooth_disabled
+      
+        # Whether all cameras on the device are disabled.
+        # Corresponds to the JSON property `cameraDisabled`
+        # @return [Boolean]
+        attr_accessor :camera_disabled
+        alias_method :camera_disabled?, :camera_disabled
+      
+        # Whether configuring cell broadcast is disabled.
+        # Corresponds to the JSON property `cellBroadcastsConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :cell_broadcasts_config_disabled
+        alias_method :cell_broadcasts_config_disabled?, :cell_broadcasts_config_disabled
+      
+        # Rules for automatically choosing a private key and certificate to authenticate
+        # the device to a server. The rules are ordered by increasing precedence, so if
+        # an outgoing request matches more than one rule, the last rule defines which
+        # private key to use.
+        # Corresponds to the JSON property `choosePrivateKeyRules`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ChoosePrivateKeyRule>]
+        attr_accessor :choose_private_key_rules
+      
+        # Rules declaring which mitigating actions to take when a device is not
+        # compliant with its policy. When the conditions for multiple rules are
+        # satisfied, all of the mitigating actions for the rules are taken. There is a
+        # maximum limit of 100 rules. Use policy enforcement rules instead.
+        # Corresponds to the JSON property `complianceRules`
+        # @return [Array<Google::Apis::AndroidmanagementV1::ComplianceRule>]
+        attr_accessor :compliance_rules
+      
+        # Whether creating windows besides app windows is disabled.
+        # Corresponds to the JSON property `createWindowsDisabled`
+        # @return [Boolean]
+        attr_accessor :create_windows_disabled
+        alias_method :create_windows_disabled?, :create_windows_disabled
+      
+        # Whether configuring user credentials is disabled.
+        # Corresponds to the JSON property `credentialsConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :credentials_config_disabled
+        alias_method :credentials_config_disabled?, :credentials_config_disabled
+      
+        # Whether roaming data services are disabled.
+        # Corresponds to the JSON property `dataRoamingDisabled`
+        # @return [Boolean]
+        attr_accessor :data_roaming_disabled
+        alias_method :data_roaming_disabled?, :data_roaming_disabled
+      
+        # Whether the user is allowed to enable debugging features.
+        # Corresponds to the JSON property `debuggingFeaturesAllowed`
+        # @return [Boolean]
+        attr_accessor :debugging_features_allowed
+        alias_method :debugging_features_allowed?, :debugging_features_allowed
+      
+        # The default permission policy for runtime permission requests.
+        # Corresponds to the JSON property `defaultPermissionPolicy`
+        # @return [String]
+        attr_accessor :default_permission_policy
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `deviceOwnerLockScreenInfo`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :device_owner_lock_screen_info
+      
+        # Whether encryption is enabled
+        # Corresponds to the JSON property `encryptionPolicy`
+        # @return [String]
+        attr_accessor :encryption_policy
+      
+        # Whether app verification is force-enabled.
+        # Corresponds to the JSON property `ensureVerifyAppsEnabled`
+        # @return [Boolean]
+        attr_accessor :ensure_verify_apps_enabled
+        alias_method :ensure_verify_apps_enabled?, :ensure_verify_apps_enabled
+      
+        # Whether factory resetting from settings is disabled.
+        # Corresponds to the JSON property `factoryResetDisabled`
+        # @return [Boolean]
+        attr_accessor :factory_reset_disabled
+        alias_method :factory_reset_disabled?, :factory_reset_disabled
+      
+        # Email addresses of device administrators for factory reset protection. When
+        # the device is factory reset, it will require one of these admins to log in
+        # with the Google account email and password to unlock the device. If no admins
+        # are specified, the device won't provide factory reset protection.
+        # Corresponds to the JSON property `frpAdminEmails`
+        # @return [Array<String>]
+        attr_accessor :frp_admin_emails
+      
+        # Whether the user is allowed to have fun. Controls whether the Easter egg game
+        # in Settings is disabled.
+        # Corresponds to the JSON property `funDisabled`
+        # @return [Boolean]
+        attr_accessor :fun_disabled
+        alias_method :fun_disabled?, :fun_disabled
+      
+        # Whether user installation of apps is disabled.
+        # Corresponds to the JSON property `installAppsDisabled`
+        # @return [Boolean]
+        attr_accessor :install_apps_disabled
+        alias_method :install_apps_disabled?, :install_apps_disabled
+      
+        # Whether the user is allowed to enable the "Unknown Sources" setting, which
+        # allows installation of apps from unknown sources.
+        # Corresponds to the JSON property `installUnknownSourcesAllowed`
+        # @return [Boolean]
+        attr_accessor :install_unknown_sources_allowed
+        alias_method :install_unknown_sources_allowed?, :install_unknown_sources_allowed
+      
+        # Whether the keyguard is disabled.
+        # Corresponds to the JSON property `keyguardDisabled`
+        # @return [Boolean]
+        attr_accessor :keyguard_disabled
+        alias_method :keyguard_disabled?, :keyguard_disabled
+      
+        # Disabled keyguard customizations, such as widgets.
+        # Corresponds to the JSON property `keyguardDisabledFeatures`
+        # @return [Array<String>]
+        attr_accessor :keyguard_disabled_features
+      
+        # Whether the kiosk custom launcher is enabled. This replaces the home screen
+        # with a launcher that locks down the device to the apps installed via the
+        # applications setting. Apps appear on a single page in alphabetical order. Use
+        # kioskCustomization to further configure the kiosk device behavior.
+        # Corresponds to the JSON property `kioskCustomLauncherEnabled`
+        # @return [Boolean]
+        attr_accessor :kiosk_custom_launcher_enabled
+        alias_method :kiosk_custom_launcher_enabled?, :kiosk_custom_launcher_enabled
+      
+        # Settings controlling the behavior of a device in kiosk mode. To enable kiosk
+        # mode, set kioskCustomLauncherEnabled to true or specify an app in the policy
+        # with installType KIOSK.
+        # Corresponds to the JSON property `kioskCustomization`
+        # @return [Google::Apis::AndroidmanagementV1::KioskCustomization]
+        attr_accessor :kiosk_customization
+      
+        # The degree of location detection enabled.
+        # Corresponds to the JSON property `locationMode`
+        # @return [String]
+        attr_accessor :location_mode
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `longSupportMessage`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :long_support_message
+      
+        # Maximum time in milliseconds for user activity until the device locks. A value
+        # of 0 means there is no restriction.
+        # Corresponds to the JSON property `maximumTimeToLock`
+        # @return [Fixnum]
+        attr_accessor :maximum_time_to_lock
+      
+        # The minimum allowed Android API level.
+        # Corresponds to the JSON property `minimumApiLevel`
+        # @return [Fixnum]
+        attr_accessor :minimum_api_level
+      
+        # Whether configuring mobile networks is disabled.
+        # Corresponds to the JSON property `mobileNetworksConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :mobile_networks_config_disabled
+        alias_method :mobile_networks_config_disabled?, :mobile_networks_config_disabled
+      
+        # Whether adding or removing accounts is disabled.
+        # Corresponds to the JSON property `modifyAccountsDisabled`
+        # @return [Boolean]
+        attr_accessor :modify_accounts_disabled
+        alias_method :modify_accounts_disabled?, :modify_accounts_disabled
+      
+        # Whether the user mounting physical external media is disabled.
+        # Corresponds to the JSON property `mountPhysicalMediaDisabled`
+        # @return [Boolean]
+        attr_accessor :mount_physical_media_disabled
+        alias_method :mount_physical_media_disabled?, :mount_physical_media_disabled
+      
+        # The name of the policy in the form enterprises/`enterpriseId`/policies/`
+        # policyId`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Whether the network escape hatch is enabled. If a network connection can't be
+        # made at boot time, the escape hatch prompts the user to temporarily connect to
+        # a network in order to refresh the device policy. After applying policy, the
+        # temporary network will be forgotten and the device will continue booting. This
+        # prevents being unable to connect to a network if there is no suitable network
+        # in the last policy and the device boots into an app in lock task mode, or the
+        # user is otherwise unable to reach device settings.
+        # Corresponds to the JSON property `networkEscapeHatchEnabled`
+        # @return [Boolean]
+        attr_accessor :network_escape_hatch_enabled
+        alias_method :network_escape_hatch_enabled?, :network_escape_hatch_enabled
+      
+        # Whether resetting network settings is disabled.
+        # Corresponds to the JSON property `networkResetDisabled`
+        # @return [Boolean]
+        attr_accessor :network_reset_disabled
+        alias_method :network_reset_disabled?, :network_reset_disabled
+      
+        # Network configuration for the device. See configure networks for more
+        # information.
+        # Corresponds to the JSON property `openNetworkConfiguration`
+        # @return [Hash<String,Object>]
+        attr_accessor :open_network_configuration
+      
+        # Whether using NFC to beam data from apps is disabled.
+        # Corresponds to the JSON property `outgoingBeamDisabled`
+        # @return [Boolean]
+        attr_accessor :outgoing_beam_disabled
+        alias_method :outgoing_beam_disabled?, :outgoing_beam_disabled
+      
+        # Whether outgoing calls are disabled.
+        # Corresponds to the JSON property `outgoingCallsDisabled`
+        # @return [Boolean]
+        attr_accessor :outgoing_calls_disabled
+        alias_method :outgoing_calls_disabled?, :outgoing_calls_disabled
+      
+        # Password requirement policies. Different policies can be set for work profile
+        # or fully managed devices by setting the password_scope field in the policy.
+        # Corresponds to the JSON property `passwordPolicies`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PasswordRequirements>]
+        attr_accessor :password_policies
+      
+        # Requirements for the password used to unlock a device.
+        # Corresponds to the JSON property `passwordRequirements`
+        # @return [Google::Apis::AndroidmanagementV1::PasswordRequirements]
+        attr_accessor :password_requirements
+      
+        # Explicit permission or group grants or denials for all apps. These values
+        # override the default_permission_policy.
+        # Corresponds to the JSON property `permissionGrants`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PermissionGrant>]
+        attr_accessor :permission_grants
+      
+        # A list of package names.
+        # Corresponds to the JSON property `permittedAccessibilityServices`
+        # @return [Google::Apis::AndroidmanagementV1::PackageNameList]
+        attr_accessor :permitted_accessibility_services
+      
+        # A list of package names.
+        # Corresponds to the JSON property `permittedInputMethods`
+        # @return [Google::Apis::AndroidmanagementV1::PackageNameList]
+        attr_accessor :permitted_input_methods
+      
+        # Default intent handler activities.
+        # Corresponds to the JSON property `persistentPreferredActivities`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PersistentPreferredActivity>]
+        attr_accessor :persistent_preferred_activities
+      
+        # Policies controlling personal usage on a company-owned device with a work
+        # profile.
+        # Corresponds to the JSON property `personalUsagePolicies`
+        # @return [Google::Apis::AndroidmanagementV1::PersonalUsagePolicies]
+        attr_accessor :personal_usage_policies
+      
+        # This mode controls which apps are available to the user in the Play Store and
+        # the behavior on the device when apps are removed from the policy.
+        # Corresponds to the JSON property `playStoreMode`
+        # @return [String]
+        attr_accessor :play_store_mode
+      
+        # Rules that define the behavior when a particular policy can not be applied on
+        # device
+        # Corresponds to the JSON property `policyEnforcementRules`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PolicyEnforcementRule>]
+        attr_accessor :policy_enforcement_rules
+      
+        # Allows showing UI on a device for a user to choose a private key alias if
+        # there are no matching rules in ChoosePrivateKeyRules. For devices below
+        # Android P, setting this may leave enterprise keys vulnerable.
+        # Corresponds to the JSON property `privateKeySelectionEnabled`
+        # @return [Boolean]
+        attr_accessor :private_key_selection_enabled
+        alias_method :private_key_selection_enabled?, :private_key_selection_enabled
+      
+        # Configuration info for an HTTP proxy. For a direct proxy, set the host, port,
+        # and excluded_hosts fields. For a PAC script proxy, set the pac_uri field.
+        # Corresponds to the JSON property `recommendedGlobalProxy`
+        # @return [Google::Apis::AndroidmanagementV1::ProxyInfo]
+        attr_accessor :recommended_global_proxy
+      
+        # Whether removing other users is disabled.
+        # Corresponds to the JSON property `removeUserDisabled`
+        # @return [Boolean]
+        attr_accessor :remove_user_disabled
+        alias_method :remove_user_disabled?, :remove_user_disabled
+      
+        # Whether rebooting the device into safe boot is disabled.
+        # Corresponds to the JSON property `safeBootDisabled`
+        # @return [Boolean]
+        attr_accessor :safe_boot_disabled
+        alias_method :safe_boot_disabled?, :safe_boot_disabled
+      
+        # Whether screen capture is disabled.
+        # Corresponds to the JSON property `screenCaptureDisabled`
+        # @return [Boolean]
+        attr_accessor :screen_capture_disabled
+        alias_method :screen_capture_disabled?, :screen_capture_disabled
+      
+        # Whether changing the user icon is disabled.
+        # Corresponds to the JSON property `setUserIconDisabled`
+        # @return [Boolean]
+        attr_accessor :set_user_icon_disabled
+        alias_method :set_user_icon_disabled?, :set_user_icon_disabled
+      
+        # Whether changing the wallpaper is disabled.
+        # Corresponds to the JSON property `setWallpaperDisabled`
+        # @return [Boolean]
+        attr_accessor :set_wallpaper_disabled
+        alias_method :set_wallpaper_disabled?, :set_wallpaper_disabled
+      
+        # Actions to take during the setup process.
+        # Corresponds to the JSON property `setupActions`
+        # @return [Array<Google::Apis::AndroidmanagementV1::SetupAction>]
+        attr_accessor :setup_actions
+      
+        # Whether location sharing is disabled.
+        # Corresponds to the JSON property `shareLocationDisabled`
+        # @return [Boolean]
+        attr_accessor :share_location_disabled
+        alias_method :share_location_disabled?, :share_location_disabled
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `shortSupportMessage`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :short_support_message
+      
+        # Flag to skip hints on the first use. Enterprise admin can enable the system
+        # recommendation for apps to skip their user tutorial and other introductory
+        # hints on first start-up.
+        # Corresponds to the JSON property `skipFirstUseHintsEnabled`
+        # @return [Boolean]
+        attr_accessor :skip_first_use_hints_enabled
+        alias_method :skip_first_use_hints_enabled?, :skip_first_use_hints_enabled
+      
+        # Whether sending and receiving SMS messages is disabled.
+        # Corresponds to the JSON property `smsDisabled`
+        # @return [Boolean]
+        attr_accessor :sms_disabled
+        alias_method :sms_disabled?, :sms_disabled
+      
+        # Whether the status bar is disabled. This disables notifications, quick
+        # settings, and other screen overlays that allow escape from full-screen mode.
+        # DEPRECATED. To disable the status bar on a kiosk device, use InstallType KIOSK
+        # or kioskCustomLauncherEnabled.
+        # Corresponds to the JSON property `statusBarDisabled`
+        # @return [Boolean]
+        attr_accessor :status_bar_disabled
+        alias_method :status_bar_disabled?, :status_bar_disabled
+      
+        # Settings controlling the behavior of status reports.
+        # Corresponds to the JSON property `statusReportingSettings`
+        # @return [Google::Apis::AndroidmanagementV1::StatusReportingSettings]
+        attr_accessor :status_reporting_settings
+      
+        # The battery plugged in modes for which the device stays on. When using this
+        # setting, it is recommended to clear maximum_time_to_lock so that the device
+        # doesn't lock itself while it stays on.
+        # Corresponds to the JSON property `stayOnPluggedModes`
+        # @return [Array<String>]
+        attr_accessor :stay_on_plugged_modes
+      
+        # Configuration for managing system updates
+        # Corresponds to the JSON property `systemUpdate`
+        # @return [Google::Apis::AndroidmanagementV1::SystemUpdate]
+        attr_accessor :system_update
+      
+        # Whether configuring tethering and portable hotspots is disabled.
+        # Corresponds to the JSON property `tetheringConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :tethering_config_disabled
+        alias_method :tethering_config_disabled?, :tethering_config_disabled
+      
+        # Whether user uninstallation of applications is disabled.
+        # Corresponds to the JSON property `uninstallAppsDisabled`
+        # @return [Boolean]
+        attr_accessor :uninstall_apps_disabled
+        alias_method :uninstall_apps_disabled?, :uninstall_apps_disabled
+      
+        # Whether the microphone is muted and adjusting microphone volume is disabled.
+        # Corresponds to the JSON property `unmuteMicrophoneDisabled`
+        # @return [Boolean]
+        attr_accessor :unmute_microphone_disabled
+        alias_method :unmute_microphone_disabled?, :unmute_microphone_disabled
+      
+        # Whether transferring files over USB is disabled.
+        # Corresponds to the JSON property `usbFileTransferDisabled`
+        # @return [Boolean]
+        attr_accessor :usb_file_transfer_disabled
+        alias_method :usb_file_transfer_disabled?, :usb_file_transfer_disabled
+      
+        # Whether USB storage is enabled. Deprecated.
+        # Corresponds to the JSON property `usbMassStorageEnabled`
+        # @return [Boolean]
+        attr_accessor :usb_mass_storage_enabled
+        alias_method :usb_mass_storage_enabled?, :usb_mass_storage_enabled
+      
+        # The version of the policy. This is a read-only field. The version is
+        # incremented each time the policy is updated.
+        # Corresponds to the JSON property `version`
+        # @return [Fixnum]
+        attr_accessor :version
+      
+        # Whether configuring VPN is disabled.
+        # Corresponds to the JSON property `vpnConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :vpn_config_disabled
+        alias_method :vpn_config_disabled?, :vpn_config_disabled
+      
+        # Whether configuring Wi-Fi access points is disabled.
+        # Corresponds to the JSON property `wifiConfigDisabled`
+        # @return [Boolean]
+        attr_accessor :wifi_config_disabled
+        alias_method :wifi_config_disabled?, :wifi_config_disabled
+      
+        # DEPRECATED - Use wifi_config_disabled.
+        # Corresponds to the JSON property `wifiConfigsLockdownEnabled`
+        # @return [Boolean]
+        attr_accessor :wifi_configs_lockdown_enabled
+        alias_method :wifi_configs_lockdown_enabled?, :wifi_configs_lockdown_enabled
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @account_types_with_management_disabled = args[:account_types_with_management_disabled] if args.key?(:account_types_with_management_disabled)
+          @add_user_disabled = args[:add_user_disabled] if args.key?(:add_user_disabled)
+          @adjust_volume_disabled = args[:adjust_volume_disabled] if args.key?(:adjust_volume_disabled)
+          @advanced_security_overrides = args[:advanced_security_overrides] if args.key?(:advanced_security_overrides)
+          @always_on_vpn_package = args[:always_on_vpn_package] if args.key?(:always_on_vpn_package)
+          @android_device_policy_tracks = args[:android_device_policy_tracks] if args.key?(:android_device_policy_tracks)
+          @app_auto_update_policy = args[:app_auto_update_policy] if args.key?(:app_auto_update_policy)
+          @applications = args[:applications] if args.key?(:applications)
+          @auto_date_and_time_zone = args[:auto_date_and_time_zone] if args.key?(:auto_date_and_time_zone)
+          @auto_time_required = args[:auto_time_required] if args.key?(:auto_time_required)
+          @block_applications_enabled = args[:block_applications_enabled] if args.key?(:block_applications_enabled)
+          @bluetooth_config_disabled = args[:bluetooth_config_disabled] if args.key?(:bluetooth_config_disabled)
+          @bluetooth_contact_sharing_disabled = args[:bluetooth_contact_sharing_disabled] if args.key?(:bluetooth_contact_sharing_disabled)
+          @bluetooth_disabled = args[:bluetooth_disabled] if args.key?(:bluetooth_disabled)
+          @camera_disabled = args[:camera_disabled] if args.key?(:camera_disabled)
+          @cell_broadcasts_config_disabled = args[:cell_broadcasts_config_disabled] if args.key?(:cell_broadcasts_config_disabled)
+          @choose_private_key_rules = args[:choose_private_key_rules] if args.key?(:choose_private_key_rules)
+          @compliance_rules = args[:compliance_rules] if args.key?(:compliance_rules)
+          @create_windows_disabled = args[:create_windows_disabled] if args.key?(:create_windows_disabled)
+          @credentials_config_disabled = args[:credentials_config_disabled] if args.key?(:credentials_config_disabled)
+          @data_roaming_disabled = args[:data_roaming_disabled] if args.key?(:data_roaming_disabled)
+          @debugging_features_allowed = args[:debugging_features_allowed] if args.key?(:debugging_features_allowed)
+          @default_permission_policy = args[:default_permission_policy] if args.key?(:default_permission_policy)
+          @device_owner_lock_screen_info = args[:device_owner_lock_screen_info] if args.key?(:device_owner_lock_screen_info)
+          @encryption_policy = args[:encryption_policy] if args.key?(:encryption_policy)
+          @ensure_verify_apps_enabled = args[:ensure_verify_apps_enabled] if args.key?(:ensure_verify_apps_enabled)
+          @factory_reset_disabled = args[:factory_reset_disabled] if args.key?(:factory_reset_disabled)
+          @frp_admin_emails = args[:frp_admin_emails] if args.key?(:frp_admin_emails)
+          @fun_disabled = args[:fun_disabled] if args.key?(:fun_disabled)
+          @install_apps_disabled = args[:install_apps_disabled] if args.key?(:install_apps_disabled)
+          @install_unknown_sources_allowed = args[:install_unknown_sources_allowed] if args.key?(:install_unknown_sources_allowed)
+          @keyguard_disabled = args[:keyguard_disabled] if args.key?(:keyguard_disabled)
+          @keyguard_disabled_features = args[:keyguard_disabled_features] if args.key?(:keyguard_disabled_features)
+          @kiosk_custom_launcher_enabled = args[:kiosk_custom_launcher_enabled] if args.key?(:kiosk_custom_launcher_enabled)
+          @kiosk_customization = args[:kiosk_customization] if args.key?(:kiosk_customization)
+          @location_mode = args[:location_mode] if args.key?(:location_mode)
+          @long_support_message = args[:long_support_message] if args.key?(:long_support_message)
+          @maximum_time_to_lock = args[:maximum_time_to_lock] if args.key?(:maximum_time_to_lock)
+          @minimum_api_level = args[:minimum_api_level] if args.key?(:minimum_api_level)
+          @mobile_networks_config_disabled = args[:mobile_networks_config_disabled] if args.key?(:mobile_networks_config_disabled)
+          @modify_accounts_disabled = args[:modify_accounts_disabled] if args.key?(:modify_accounts_disabled)
+          @mount_physical_media_disabled = args[:mount_physical_media_disabled] if args.key?(:mount_physical_media_disabled)
+          @name = args[:name] if args.key?(:name)
+          @network_escape_hatch_enabled = args[:network_escape_hatch_enabled] if args.key?(:network_escape_hatch_enabled)
+          @network_reset_disabled = args[:network_reset_disabled] if args.key?(:network_reset_disabled)
+          @open_network_configuration = args[:open_network_configuration] if args.key?(:open_network_configuration)
+          @outgoing_beam_disabled = args[:outgoing_beam_disabled] if args.key?(:outgoing_beam_disabled)
+          @outgoing_calls_disabled = args[:outgoing_calls_disabled] if args.key?(:outgoing_calls_disabled)
+          @password_policies = args[:password_policies] if args.key?(:password_policies)
+          @password_requirements = args[:password_requirements] if args.key?(:password_requirements)
+          @permission_grants = args[:permission_grants] if args.key?(:permission_grants)
+          @permitted_accessibility_services = args[:permitted_accessibility_services] if args.key?(:permitted_accessibility_services)
+          @permitted_input_methods = args[:permitted_input_methods] if args.key?(:permitted_input_methods)
+          @persistent_preferred_activities = args[:persistent_preferred_activities] if args.key?(:persistent_preferred_activities)
+          @personal_usage_policies = args[:personal_usage_policies] if args.key?(:personal_usage_policies)
+          @play_store_mode = args[:play_store_mode] if args.key?(:play_store_mode)
+          @policy_enforcement_rules = args[:policy_enforcement_rules] if args.key?(:policy_enforcement_rules)
+          @private_key_selection_enabled = args[:private_key_selection_enabled] if args.key?(:private_key_selection_enabled)
+          @recommended_global_proxy = args[:recommended_global_proxy] if args.key?(:recommended_global_proxy)
+          @remove_user_disabled = args[:remove_user_disabled] if args.key?(:remove_user_disabled)
+          @safe_boot_disabled = args[:safe_boot_disabled] if args.key?(:safe_boot_disabled)
+          @screen_capture_disabled = args[:screen_capture_disabled] if args.key?(:screen_capture_disabled)
+          @set_user_icon_disabled = args[:set_user_icon_disabled] if args.key?(:set_user_icon_disabled)
+          @set_wallpaper_disabled = args[:set_wallpaper_disabled] if args.key?(:set_wallpaper_disabled)
+          @setup_actions = args[:setup_actions] if args.key?(:setup_actions)
+          @share_location_disabled = args[:share_location_disabled] if args.key?(:share_location_disabled)
+          @short_support_message = args[:short_support_message] if args.key?(:short_support_message)
+          @skip_first_use_hints_enabled = args[:skip_first_use_hints_enabled] if args.key?(:skip_first_use_hints_enabled)
+          @sms_disabled = args[:sms_disabled] if args.key?(:sms_disabled)
+          @status_bar_disabled = args[:status_bar_disabled] if args.key?(:status_bar_disabled)
+          @status_reporting_settings = args[:status_reporting_settings] if args.key?(:status_reporting_settings)
+          @stay_on_plugged_modes = args[:stay_on_plugged_modes] if args.key?(:stay_on_plugged_modes)
+          @system_update = args[:system_update] if args.key?(:system_update)
+          @tethering_config_disabled = args[:tethering_config_disabled] if args.key?(:tethering_config_disabled)
+          @uninstall_apps_disabled = args[:uninstall_apps_disabled] if args.key?(:uninstall_apps_disabled)
+          @unmute_microphone_disabled = args[:unmute_microphone_disabled] if args.key?(:unmute_microphone_disabled)
+          @usb_file_transfer_disabled = args[:usb_file_transfer_disabled] if args.key?(:usb_file_transfer_disabled)
+          @usb_mass_storage_enabled = args[:usb_mass_storage_enabled] if args.key?(:usb_mass_storage_enabled)
+          @version = args[:version] if args.key?(:version)
+          @vpn_config_disabled = args[:vpn_config_disabled] if args.key?(:vpn_config_disabled)
+          @wifi_config_disabled = args[:wifi_config_disabled] if args.key?(:wifi_config_disabled)
+          @wifi_configs_lockdown_enabled = args[:wifi_configs_lockdown_enabled] if args.key?(:wifi_configs_lockdown_enabled)
+        end
+      end
+      
+      # A rule that defines the actions to take if a device or work profile is not
+      # compliant with the policy specified in settingName.
+      class PolicyEnforcementRule
+        include Google::Apis::Core::Hashable
+      
+        # An action to block access to apps and data on a fully managed device or in a
+        # work profile. This action also triggers a device or work profile to displays a
+        # user-facing notification with information (where possible) on how to correct
+        # the compliance issue. Note: wipeAction must also be specified.
+        # Corresponds to the JSON property `blockAction`
+        # @return [Google::Apis::AndroidmanagementV1::BlockAction]
+        attr_accessor :block_action
+      
+        # The top-level policy to enforce. For example, applications or passwordPolicies.
+        # Corresponds to the JSON property `settingName`
+        # @return [String]
+        attr_accessor :setting_name
+      
+        # An action to reset a fully managed device or delete a work profile. Note:
+        # blockAction must also be specified.
+        # Corresponds to the JSON property `wipeAction`
+        # @return [Google::Apis::AndroidmanagementV1::WipeAction]
+        attr_accessor :wipe_action
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @block_action = args[:block_action] if args.key?(:block_action)
+          @setting_name = args[:setting_name] if args.key?(:setting_name)
+          @wipe_action = args[:wipe_action] if args.key?(:wipe_action)
+        end
+      end
+      
+      # Additional details regarding the security posture of the device.
+      class PostureDetail
+        include Google::Apis::Core::Hashable
+      
+        # Corresponding admin-facing advice to mitigate this security risk and improve
+        # the security posture of the device.
+        # Corresponds to the JSON property `advice`
+        # @return [Array<Google::Apis::AndroidmanagementV1::UserFacingMessage>]
+        attr_accessor :advice
+      
+        # A specific security risk that negatively affects the security posture of the
+        # device.
+        # Corresponds to the JSON property `securityRisk`
+        # @return [String]
+        attr_accessor :security_risk
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @advice = args[:advice] if args.key?(:advice)
+          @security_risk = args[:security_risk] if args.key?(:security_risk)
+        end
+      end
+      
+      # A power management event.
+      class PowerManagementEvent
+        include Google::Apis::Core::Hashable
+      
+        # For BATTERY_LEVEL_COLLECTED events, the battery level as a percentage.
+        # Corresponds to the JSON property `batteryLevel`
+        # @return [Float]
+        attr_accessor :battery_level
+      
+        # The creation time of the event.
+        # Corresponds to the JSON property `createTime`
+        # @return [String]
+        attr_accessor :create_time
+      
+        # Event type.
+        # Corresponds to the JSON property `eventType`
+        # @return [String]
+        attr_accessor :event_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @battery_level = args[:battery_level] if args.key?(:battery_level)
+          @create_time = args[:create_time] if args.key?(:create_time)
+          @event_type = args[:event_type] if args.key?(:event_type)
+        end
+      end
+      
+      # Configuration info for an HTTP proxy. For a direct proxy, set the host, port,
+      # and excluded_hosts fields. For a PAC script proxy, set the pac_uri field.
+      class ProxyInfo
+        include Google::Apis::Core::Hashable
+      
+        # For a direct proxy, the hosts for which the proxy is bypassed. The host names
+        # may contain wildcards such as *.example.com.
+        # Corresponds to the JSON property `excludedHosts`
+        # @return [Array<String>]
+        attr_accessor :excluded_hosts
+      
+        # The host of the direct proxy.
+        # Corresponds to the JSON property `host`
+        # @return [String]
+        attr_accessor :host
+      
+        # The URI of the PAC script used to configure the proxy.
+        # Corresponds to the JSON property `pacUri`
+        # @return [String]
+        attr_accessor :pac_uri
+      
+        # The port of the direct proxy.
+        # Corresponds to the JSON property `port`
+        # @return [Fixnum]
+        attr_accessor :port
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @excluded_hosts = args[:excluded_hosts] if args.key?(:excluded_hosts)
+          @host = args[:host] if args.key?(:host)
+          @pac_uri = args[:pac_uri] if args.key?(:pac_uri)
+          @port = args[:port] if args.key?(:port)
+        end
+      end
+      
+      # The security posture of the device, as determined by the current device state
+      # and the policies applied.
+      class SecurityPosture
+        include Google::Apis::Core::Hashable
+      
+        # Device's security posture value.
+        # Corresponds to the JSON property `devicePosture`
+        # @return [String]
+        attr_accessor :device_posture
+      
+        # Additional details regarding the security posture of the device.
+        # Corresponds to the JSON property `postureDetails`
+        # @return [Array<Google::Apis::AndroidmanagementV1::PostureDetail>]
+        attr_accessor :posture_details
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @device_posture = args[:device_posture] if args.key?(:device_posture)
+          @posture_details = args[:posture_details] if args.key?(:posture_details)
+        end
+      end
+      
+      # An action executed during setup.
+      class SetupAction
+        include Google::Apis::Core::Hashable
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `description`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :description
+      
+        # An action to launch an app.
+        # Corresponds to the JSON property `launchApp`
+        # @return [Google::Apis::AndroidmanagementV1::LaunchAppAction]
+        attr_accessor :launch_app
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `title`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :title
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @description = args[:description] if args.key?(:description)
+          @launch_app = args[:launch_app] if args.key?(:launch_app)
+          @title = args[:title] if args.key?(:title)
+        end
+      end
+      
+      # A resource containing sign in details for an enterprise.
+      class SigninDetail
+        include Google::Apis::Core::Hashable
+      
+        # Controls whether personal usage is allowed on a device provisioned with this
+        # enrollment token.For company-owned devices: Enabling personal usage allows the
+        # user to set up a work profile on the device. Disabling personal usage requires
+        # the user provision the device as a fully managed device.For personally-owned
+        # devices: Enabling personal usage allows the user to set up a work profile on
+        # the device. Disabling personal usage will prevent the device from provisioning.
+        # Personal usage cannot be disabled on personally-owned device.
+        # Corresponds to the JSON property `allowPersonalUsage`
+        # @return [String]
+        attr_accessor :allow_personal_usage
+      
+        # A JSON string whose UTF-8 representation can be used to generate a QR code to
+        # enroll a device with this enrollment token. To enroll a device using NFC, the
+        # NFC record must contain a serialized java.util.Properties representation of
+        # the properties in the JSON. This is a read-only field generated by the server.
+        # Corresponds to the JSON property `qrCode`
+        # @return [String]
+        attr_accessor :qr_code
+      
+        # An enterprise wide enrollment token used to trigger custom sign-in flow. This
+        # is a read-only field generated by the server.
+        # Corresponds to the JSON property `signinEnrollmentToken`
+        # @return [String]
+        attr_accessor :signin_enrollment_token
+      
+        # Sign-in URL for authentication when device is provisioned with a sign-in
+        # enrollment token. The sign-in endpoint should finish authentication flow with
+        # a URL in the form of https://enterprise.google.com/android/enroll?et= for a
+        # successful login, or https://enterprise.google.com/android/enroll/invalid for
+        # a failed login.
+        # Corresponds to the JSON property `signinUrl`
+        # @return [String]
+        attr_accessor :signin_url
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @allow_personal_usage = args[:allow_personal_usage] if args.key?(:allow_personal_usage)
+          @qr_code = args[:qr_code] if args.key?(:qr_code)
+          @signin_enrollment_token = args[:signin_enrollment_token] if args.key?(:signin_enrollment_token)
+          @signin_url = args[:signin_url] if args.key?(:signin_url)
+        end
+      end
+      
+      # An enterprise signup URL.
+      class SignupUrl
+        include Google::Apis::Core::Hashable
+      
+        # The name of the resource. Use this value in the signupUrl field when calling
+        # enterprises.create to complete the enterprise signup flow.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # A URL where an enterprise admin can register their enterprise. The page can't
+        # be rendered in an iframe.
+        # Corresponds to the JSON property `url`
+        # @return [String]
+        attr_accessor :url
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @name = args[:name] if args.key?(:name)
+          @url = args[:url] if args.key?(:url)
+        end
+      end
+      
+      # Information about device software.
+      class SoftwareInfo
+        include Google::Apis::Core::Hashable
+      
+        # Android build ID string meant for displaying to the user. For example, shamu-
+        # userdebug 6.0.1 MOB30I 2756745 dev-keys.
+        # Corresponds to the JSON property `androidBuildNumber`
+        # @return [String]
+        attr_accessor :android_build_number
+      
+        # Build time.
+        # Corresponds to the JSON property `androidBuildTime`
+        # @return [String]
+        attr_accessor :android_build_time
+      
+        # The Android Device Policy app version code.
+        # Corresponds to the JSON property `androidDevicePolicyVersionCode`
+        # @return [Fixnum]
+        attr_accessor :android_device_policy_version_code
+      
+        # The Android Device Policy app version as displayed to the user.
+        # Corresponds to the JSON property `androidDevicePolicyVersionName`
+        # @return [String]
+        attr_accessor :android_device_policy_version_name
+      
+        # The user-visible Android version string. For example, 6.0.1.
+        # Corresponds to the JSON property `androidVersion`
+        # @return [String]
+        attr_accessor :android_version
+      
+        # The system bootloader version number, e.g. 0.6.7.
+        # Corresponds to the JSON property `bootloaderVersion`
+        # @return [String]
+        attr_accessor :bootloader_version
+      
+        # SHA-256 hash of android.content.pm.Signature (https://developer.android.com/
+        # reference/android/content/pm/Signature.html) associated with the system
+        # package, which can be used to verify that the system build hasn't been
+        # modified.
+        # Corresponds to the JSON property `deviceBuildSignature`
+        # @return [String]
+        attr_accessor :device_build_signature
+      
+        # Kernel version, for example, 2.6.32.9-g103d848.
+        # Corresponds to the JSON property `deviceKernelVersion`
+        # @return [String]
+        attr_accessor :device_kernel_version
+      
+        # An IETF BCP 47 language code for the primary locale on the device.
+        # Corresponds to the JSON property `primaryLanguageCode`
+        # @return [String]
+        attr_accessor :primary_language_code
+      
+        # Security patch level, e.g. 2016-05-01.
+        # Corresponds to the JSON property `securityPatchLevel`
+        # @return [String]
+        attr_accessor :security_patch_level
+      
+        # Information about a potential pending system update.
+        # Corresponds to the JSON property `systemUpdateInfo`
+        # @return [Google::Apis::AndroidmanagementV1::SystemUpdateInfo]
+        attr_accessor :system_update_info
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @android_build_number = args[:android_build_number] if args.key?(:android_build_number)
+          @android_build_time = args[:android_build_time] if args.key?(:android_build_time)
+          @android_device_policy_version_code = args[:android_device_policy_version_code] if args.key?(:android_device_policy_version_code)
+          @android_device_policy_version_name = args[:android_device_policy_version_name] if args.key?(:android_device_policy_version_name)
+          @android_version = args[:android_version] if args.key?(:android_version)
+          @bootloader_version = args[:bootloader_version] if args.key?(:bootloader_version)
+          @device_build_signature = args[:device_build_signature] if args.key?(:device_build_signature)
+          @device_kernel_version = args[:device_kernel_version] if args.key?(:device_kernel_version)
+          @primary_language_code = args[:primary_language_code] if args.key?(:primary_language_code)
+          @security_patch_level = args[:security_patch_level] if args.key?(:security_patch_level)
+          @system_update_info = args[:system_update_info] if args.key?(:system_update_info)
+        end
+      end
+      
+      # The Status type defines a logical error model that is suitable for different
+      # programming environments, including REST APIs and RPC APIs. It is used by gRPC
+      # (https://github.com/grpc). Each Status message contains three pieces of data:
+      # error code, error message, and error details.You can find out more about this
+      # error model and how to work with it in the API Design Guide (https://cloud.
+      # google.com/apis/design/errors).
+      class Status
+        include Google::Apis::Core::Hashable
+      
+        # The status code, which should be an enum value of google.rpc.Code.
+        # Corresponds to the JSON property `code`
+        # @return [Fixnum]
+        attr_accessor :code
+      
+        # A list of messages that carry the error details. There is a common set of
+        # message types for APIs to use.
+        # Corresponds to the JSON property `details`
+        # @return [Array<Hash<String,Object>>]
+        attr_accessor :details
+      
+        # A developer-facing error message, which should be in English. Any user-facing
+        # error message should be localized and sent in the google.rpc.Status.details
+        # field, or localized by the client.
+        # Corresponds to the JSON property `message`
+        # @return [String]
+        attr_accessor :message
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @code = args[:code] if args.key?(:code)
+          @details = args[:details] if args.key?(:details)
+          @message = args[:message] if args.key?(:message)
+        end
+      end
+      
+      # Settings controlling the behavior of status reports.
+      class StatusReportingSettings
+        include Google::Apis::Core::Hashable
+      
+        # Settings controlling the behavior of application reports.
+        # Corresponds to the JSON property `applicationReportingSettings`
+        # @return [Google::Apis::AndroidmanagementV1::ApplicationReportingSettings]
+        attr_accessor :application_reporting_settings
+      
+        # Whether app reports are enabled.
+        # Corresponds to the JSON property `applicationReportsEnabled`
+        # @return [Boolean]
+        attr_accessor :application_reports_enabled
+        alias_method :application_reports_enabled?, :application_reports_enabled
+      
+        # Whether Common Criteria Mode reporting is enabled.
+        # Corresponds to the JSON property `commonCriteriaModeEnabled`
+        # @return [Boolean]
+        attr_accessor :common_criteria_mode_enabled
+        alias_method :common_criteria_mode_enabled?, :common_criteria_mode_enabled
+      
+        # Whether device settings reporting is enabled.
+        # Corresponds to the JSON property `deviceSettingsEnabled`
+        # @return [Boolean]
+        attr_accessor :device_settings_enabled
+        alias_method :device_settings_enabled?, :device_settings_enabled
+      
+        # Whether displays reporting is enabled. Report data is not available for
+        # personally owned devices with work profiles.
+        # Corresponds to the JSON property `displayInfoEnabled`
+        # @return [Boolean]
+        attr_accessor :display_info_enabled
+        alias_method :display_info_enabled?, :display_info_enabled
+      
+        # Whether hardware status reporting is enabled. Report data is not available for
+        # personally owned devices with work profiles.
+        # Corresponds to the JSON property `hardwareStatusEnabled`
+        # @return [Boolean]
+        attr_accessor :hardware_status_enabled
+        alias_method :hardware_status_enabled?, :hardware_status_enabled
+      
+        # Whether memory reporting is enabled.
+        # Corresponds to the JSON property `memoryInfoEnabled`
+        # @return [Boolean]
+        attr_accessor :memory_info_enabled
+        alias_method :memory_info_enabled?, :memory_info_enabled
+      
+        # Whether network info reporting is enabled.
+        # Corresponds to the JSON property `networkInfoEnabled`
+        # @return [Boolean]
+        attr_accessor :network_info_enabled
+        alias_method :network_info_enabled?, :network_info_enabled
+      
+        # Whether power management event reporting is enabled. Report data is not
+        # available for personally owned devices with work profiles.
+        # Corresponds to the JSON property `powerManagementEventsEnabled`
+        # @return [Boolean]
+        attr_accessor :power_management_events_enabled
+        alias_method :power_management_events_enabled?, :power_management_events_enabled
+      
+        # Whether software info reporting is enabled.
+        # Corresponds to the JSON property `softwareInfoEnabled`
+        # @return [Boolean]
+        attr_accessor :software_info_enabled
+        alias_method :software_info_enabled?, :software_info_enabled
+      
+        # Whether system properties reporting is enabled.
+        # Corresponds to the JSON property `systemPropertiesEnabled`
+        # @return [Boolean]
+        attr_accessor :system_properties_enabled
+        alias_method :system_properties_enabled?, :system_properties_enabled
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @application_reporting_settings = args[:application_reporting_settings] if args.key?(:application_reporting_settings)
+          @application_reports_enabled = args[:application_reports_enabled] if args.key?(:application_reports_enabled)
+          @common_criteria_mode_enabled = args[:common_criteria_mode_enabled] if args.key?(:common_criteria_mode_enabled)
+          @device_settings_enabled = args[:device_settings_enabled] if args.key?(:device_settings_enabled)
+          @display_info_enabled = args[:display_info_enabled] if args.key?(:display_info_enabled)
+          @hardware_status_enabled = args[:hardware_status_enabled] if args.key?(:hardware_status_enabled)
+          @memory_info_enabled = args[:memory_info_enabled] if args.key?(:memory_info_enabled)
+          @network_info_enabled = args[:network_info_enabled] if args.key?(:network_info_enabled)
+          @power_management_events_enabled = args[:power_management_events_enabled] if args.key?(:power_management_events_enabled)
+          @software_info_enabled = args[:software_info_enabled] if args.key?(:software_info_enabled)
+          @system_properties_enabled = args[:system_properties_enabled] if args.key?(:system_properties_enabled)
+        end
+      end
+      
+      # Configuration for managing system updates
+      class SystemUpdate
+        include Google::Apis::Core::Hashable
+      
+        # If the type is WINDOWED, the end of the maintenance window, measured as the
+        # number of minutes after midnight in device's local time. This value must be
+        # between 0 and 1439, inclusive. If this value is less than start_minutes, then
+        # the maintenance window spans midnight. If the maintenance window specified is
+        # smaller than 30 minutes, the actual window is extended to 30 minutes beyond
+        # the start time.
+        # Corresponds to the JSON property `endMinutes`
+        # @return [Fixnum]
+        attr_accessor :end_minutes
+      
+        # An annually repeating time period in which over-the-air (OTA) system updates
+        # are postponed to freeze the OS version running on a device. To prevent
+        # freezing the device indefinitely, each freeze period must be separated by at
+        # least 60 days.
+        # Corresponds to the JSON property `freezePeriods`
+        # @return [Array<Google::Apis::AndroidmanagementV1::FreezePeriod>]
+        attr_accessor :freeze_periods
+      
+        # If the type is WINDOWED, the start of the maintenance window, measured as the
+        # number of minutes after midnight in the device's local time. This value must
+        # be between 0 and 1439, inclusive.
+        # Corresponds to the JSON property `startMinutes`
+        # @return [Fixnum]
+        attr_accessor :start_minutes
+      
+        # The type of system update to configure.
+        # 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)
+          @end_minutes = args[:end_minutes] if args.key?(:end_minutes)
+          @freeze_periods = args[:freeze_periods] if args.key?(:freeze_periods)
+          @start_minutes = args[:start_minutes] if args.key?(:start_minutes)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # Information about a potential pending system update.
+      class SystemUpdateInfo
+        include Google::Apis::Core::Hashable
+      
+        # The time when the update was first available. A zero value indicates that this
+        # field is not set. This field is set only if an update is available (that is,
+        # updateStatus is neither UPDATE_STATUS_UNKNOWN nor UP_TO_DATE).
+        # Corresponds to the JSON property `updateReceivedTime`
+        # @return [String]
+        attr_accessor :update_received_time
+      
+        # The status of an update: whether an update exists and what type it is.
+        # Corresponds to the JSON property `updateStatus`
+        # @return [String]
+        attr_accessor :update_status
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @update_received_time = args[:update_received_time] if args.key?(:update_received_time)
+          @update_status = args[:update_status] if args.key?(:update_status)
+        end
+      end
+      
+      # A terms and conditions page to be accepted during provisioning.
+      class TermsAndConditions
+        include Google::Apis::Core::Hashable
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `content`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :content
+      
+        # Provides a user-facing message with locale info. The maximum message length is
+        # 4096 characters.
+        # Corresponds to the JSON property `header`
+        # @return [Google::Apis::AndroidmanagementV1::UserFacingMessage]
+        attr_accessor :header
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @content = args[:content] if args.key?(:content)
+          @header = args[:header] if args.key?(:header)
+        end
+      end
+      
+      # A user belonging to an enterprise.
+      class User
+        include Google::Apis::Core::Hashable
+      
+        # A unique identifier you create for this user, such as user342 or asset#44418.
+        # This field must be set when the user is created and can't be updated. This
+        # field must not contain personally identifiable information (PII). This
+        # identifier must be 1024 characters or less; otherwise, the update policy
+        # request will fail.
+        # Corresponds to the JSON property `accountIdentifier`
+        # @return [String]
+        attr_accessor :account_identifier
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @account_identifier = args[:account_identifier] if args.key?(:account_identifier)
+        end
+      end
+      
+      # Provides a user-facing message with locale info. The maximum message length is
+      # 4096 characters.
+      class UserFacingMessage
+        include Google::Apis::Core::Hashable
+      
+        # The default message displayed if no localized message is specified or the user'
+        # s locale doesn't match with any of the localized messages. A default message
+        # must be provided if any localized messages are provided.
+        # Corresponds to the JSON property `defaultMessage`
+        # @return [String]
+        attr_accessor :default_message
+      
+        # A map containing pairs, where locale is a well-formed BCP 47 language (https://
+        # www.w3.org/International/articles/language-tags/) code, such as en-US, es-ES,
+        # or fr.
+        # Corresponds to the JSON property `localizedMessages`
+        # @return [Hash<String,String>]
+        attr_accessor :localized_messages
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @default_message = args[:default_message] if args.key?(:default_message)
+          @localized_messages = args[:localized_messages] if args.key?(:localized_messages)
+        end
+      end
+      
+      # A web app.
+      class WebApp
+        include Google::Apis::Core::Hashable
+      
+        # The display mode of the web app.
+        # Corresponds to the JSON property `displayMode`
+        # @return [String]
+        attr_accessor :display_mode
+      
+        # A list of icons for the web app. Must have at least one element.
+        # Corresponds to the JSON property `icons`
+        # @return [Array<Google::Apis::AndroidmanagementV1::WebAppIcon>]
+        attr_accessor :icons
+      
+        # The name of the web app, which is generated by the server during creation in
+        # the form enterprises/`enterpriseId`/webApps/`packageName`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The start URL, i.e. the URL that should load when the user opens the
+        # application.
+        # Corresponds to the JSON property `startUrl`
+        # @return [String]
+        attr_accessor :start_url
+      
+        # The title of the web app as displayed to the user (e.g., amongst a list of
+        # other applications, or as a label for an icon).
+        # Corresponds to the JSON property `title`
+        # @return [String]
+        attr_accessor :title
+      
+        # The current version of the app.Note that the version can automatically
+        # increase during the lifetime of the web app, while Google does internal
+        # housekeeping to keep the web app up-to-date.
+        # Corresponds to the JSON property `versionCode`
+        # @return [Fixnum]
+        attr_accessor :version_code
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @display_mode = args[:display_mode] if args.key?(:display_mode)
+          @icons = args[:icons] if args.key?(:icons)
+          @name = args[:name] if args.key?(:name)
+          @start_url = args[:start_url] if args.key?(:start_url)
+          @title = args[:title] if args.key?(:title)
+          @version_code = args[:version_code] if args.key?(:version_code)
+        end
+      end
+      
+      # An icon for a web app. Supported formats are: png, jpg and webp.
+      class WebAppIcon
+        include Google::Apis::Core::Hashable
+      
+        # The actual bytes of the image in a base64url encoded string (c.f. RFC4648,
+        # section 5 "Base 64 Encoding with URL and Filename Safe Alphabet"). - The image
+        # type can be png or jpg. - The image should ideally be square. - The image
+        # should ideally have a size of 512x512.
+        # Corresponds to the JSON property `imageData`
+        # @return [String]
+        attr_accessor :image_data
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @image_data = args[:image_data] if args.key?(:image_data)
+        end
+      end
+      
+      # A web token used to access the managed Google Play iframe.
+      class WebToken
+        include Google::Apis::Core::Hashable
+      
+        # The features to enable. Use this if you want to control exactly which feature(
+        # s) will be activated; leave empty to allow all features.Restrictions / things
+        # to note: - If no features are listed here, all features are enabled — this is
+        # the default behavior where you give access to all features to your admins. -
+        # This must not contain any FEATURE_UNSPECIFIED values. - Repeated values are
+        # ignored
+        # Corresponds to the JSON property `enabledFeatures`
+        # @return [Array<String>]
+        attr_accessor :enabled_features
+      
+        # The name of the web token, which is generated by the server during creation in
+        # the form enterprises/`enterpriseId`/webTokens/`webTokenId`.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # The URL of the parent frame hosting the iframe with the embedded UI. To
+        # prevent XSS, the iframe may not be hosted at other URLs. The URL must use the
+        # https scheme.
+        # Corresponds to the JSON property `parentFrameUrl`
+        # @return [String]
+        attr_accessor :parent_frame_url
+      
+        # Permissions available to an admin in the embedded UI. An admin must have all
+        # of these permissions in order to view the UI. This field is deprecated.
+        # Corresponds to the JSON property `permissions`
+        # @return [Array<String>]
+        attr_accessor :permissions
+      
+        # The token value which is used in the hosting page to generate the iframe with
+        # the embedded UI. This is a read-only field generated by the server.
+        # Corresponds to the JSON property `value`
+        # @return [String]
+        attr_accessor :value
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @enabled_features = args[:enabled_features] if args.key?(:enabled_features)
+          @name = args[:name] if args.key?(:name)
+          @parent_frame_url = args[:parent_frame_url] if args.key?(:parent_frame_url)
+          @permissions = args[:permissions] if args.key?(:permissions)
+          @value = args[:value] if args.key?(:value)
+        end
+      end
+      
+      # An action to reset a fully managed device or delete a work profile. Note:
+      # blockAction must also be specified.
+      class WipeAction
+        include Google::Apis::Core::Hashable
+      
+        # Whether the factory-reset protection data is preserved on the device. This
+        # setting doesn’t apply to work profiles.
+        # Corresponds to the JSON property `preserveFrp`
+        # @return [Boolean]
+        attr_accessor :preserve_frp
+        alias_method :preserve_frp?, :preserve_frp
+      
+        # Number of days the policy is non-compliant before the device or work profile
+        # is wiped. wipeAfterDays must be greater than blockAfterDays.
+        # Corresponds to the JSON property `wipeAfterDays`
+        # @return [Fixnum]
+        attr_accessor :wipe_after_days
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @preserve_frp = args[:preserve_frp] if args.key?(:preserve_frp)
+          @wipe_after_days = args[:wipe_after_days] if args.key?(:wipe_after_days)
+        end
+      end
+    end
+  end
+end