# Copyright 2015 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module 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 # 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) @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] 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] 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] 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] attr_accessor :accessible_track_ids # 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] 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] 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] 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) @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] 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] 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] 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] 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] 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 # 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] 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, e.g. a birthday. The time of day # and time zone are either specified elsewhere or are not significant. The date # is relative to the Proleptic Gregorian Calendar. This can represent: A full # date, with non-zero year, month and day values A month and day value, with a # zero year, e.g. an anniversary A year on its own, with zero month and day # values A year and month value, with a zero day, e.g. a credit card expiration # dateRelated types are google.type.TimeOfDay and google.protobuf.Timestamp. class Date include Google::Apis::Core::Hashable # Day of month. Must be from 1 to 31 and valid for the year and month, or 0 if # specifying a year by itself or a year and month where the day is not # significant. # Corresponds to the JSON property `day` # @return [Fixnum] attr_accessor :day # Month of year. Must be from 1 to 12, or 0 if specifying a year without a month # and day. # Corresponds to the JSON property `month` # @return [Fixnum] attr_accessor :month # Year of date. Must be from 1 to 9999, or 0 if specifying 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] 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 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] 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] 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] 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] 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] 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] 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] 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) @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] 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] 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] 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, e.g. a birthday. The time of day # and time zone are either specified elsewhere or are not significant. The date # is relative to the Proleptic Gregorian Calendar. This can represent: A full # date, with non-zero year, month and day values A month and day value, with a # zero year, e.g. an anniversary A year on its own, with zero month and day # values A year and month value, with a zero day, e.g. 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, e.g. a birthday. The time of day # and time zone are either specified elsewhere or are not significant. The date # is relative to the Proleptic Gregorian Calendar. This can represent: A full # date, with non-zero year, month and day values A month and day value, with a # zero year, e.g. an anniversary A year on its own, with zero month and day # values A year and month value, with a zero day, e.g. 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] 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] 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] 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] 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] 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] 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] attr_accessor :skin_shutdown_temperatures # Device skin throttling temperature thresholds in Celsius. # Corresponds to the JSON property `skinThrottlingTemperatures` # @return [Array] 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] attr_accessor :battery_temperatures # Current CPU temperatures in Celsius for each CPU on the device. # Corresponds to the JSON property `cpuTemperatures` # @return [Array] 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] 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] attr_accessor :fan_speeds # Current GPU temperatures in Celsius for each GPU on the device. # Corresponds to the JSON property `gpuTemperatures` # @return [Array] attr_accessor :gpu_temperatures # Current device skin temperatures in Celsius. # Corresponds to the JSON property `skinTemperatures` # @return [Array] 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] 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] 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] 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] 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] 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] 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] 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] 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] 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] 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] 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] 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] 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] attr_accessor :personal_applications # Used together with personal_applications 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] 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] 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] attr_accessor :applications # Whether auto time is required, which prevents the user from manually setting # the date and time. # 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] 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] 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] 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] 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. The user may change the value unless # the user is otherwise blocked from accessing device settings. # 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] 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] 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] 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] 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] 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] 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] 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_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] 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] 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] 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>] 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 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) @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] 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] 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] 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] 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] 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