googleapis/build/src/apis/androidmanagement/v1.d.ts

Google APIs Client Library for Node.js

/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * 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.
 */
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
 * Android Management API
 *
 * The Android Management API provides remote enterprise management of Android
 * devices and apps.
 *
 * @example
 * const google = require('googleapis');
 * const androidmanagement = google.androidmanagement('v1');
 *
 * @namespace androidmanagement
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for Androidmanagement
 */
export declare class Androidmanagement {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    enterprises: Resource$Enterprises;
    signupUrls: Resource$Signupurls;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * Configuration for an always-on VPN connection.
 */
export interface Schema$AlwaysOnVpnPackage {
    /**
     * Disallows networking when the VPN is not connected.
     */
    lockdownEnabled: boolean;
    /**
     * The package name of the VPN app.
     */
    packageName: string;
}
/**
 * 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.
 */
export interface Schema$ApiLevelCondition {
    /**
     * 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.
     */
    minApiLevel: number;
}
/**
 * Information about an app.
 */
export interface Schema$Application {
    /**
     * The set of managed properties available to be pre-configured for the app.
     */
    managedProperties: Schema$ManagedProperty[];
    /**
     * The name of the app in the form
     * enterprises/{enterpriseId}/applications/{package_name}.
     */
    name: string;
    /**
     * The permissions required by the app.
     */
    permissions: Schema$ApplicationPermission[];
    /**
     * The title of the app. Localized.
     */
    title: string;
}
/**
 * A permission required by the app.
 */
export interface Schema$ApplicationPermission {
    /**
     * A longer description of the permission, providing more detail on what it
     * affects. Localized.
     */
    description: string;
    /**
     * The name of the permission. Localized.
     */
    name: string;
    /**
     * An opaque string uniquely identifying the permission. Not localized.
     */
    permissionId: string;
}
/**
 * Policy for an individual app.
 */
export interface Schema$ApplicationPolicy {
    /**
     * 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.
     */
    defaultPermissionPolicy: string;
    /**
     * The scopes delegated to the app from Android Device Policy.
     */
    delegatedScopes: string[];
    /**
     * The type of installation to perform.
     */
    installType: string;
    /**
     * Whether the app is allowed to lock itself in full-screen mode.
     */
    lockTaskAllowed: boolean;
    /**
     * 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: <table>
     * <tr><td><i>type</i></td><td><i>JSON
     * value</i></td></tr>
     * <tr><td>BOOL</td><td>true or
     * false</td></tr>
     * <tr><td>STRING</td><td>string</td></tr>
     * <tr><td>INTEGER</td><td>number</td></tr>
     * <tr><td>CHOICE</td><td>string</td></tr>
     * <tr><td>MULTISELECT</td><td>array of
     * strings</td></tr>
     * <tr><td>HIDDEN</td><td>string</td></tr>
     * <tr><td>BUNDLE_ARRAY</td><td>array of
     * objects</td></tr> </table>
     */
    managedConfiguration: any;
    /**
     * 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.
     */
    minimumVersionCode: number;
    /**
     * The package name of the app. For example, com.google.android.youtube for
     * the YouTube app.
     */
    packageName: string;
    /**
     * Explicit permission grants or denials for the app. These values override
     * the default_permission_policy.
     */
    permissionGrants: Schema$PermissionGrant[];
}
/**
 * A command.
 */
export interface Schema$Command {
    /**
     * The timestamp at which the command was created. The timestamp is
     * automatically generated by the server.
     */
    createTime: string;
    /**
     * 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.
     */
    duration: string;
    /**
     * If the command failed, an error code explaining the failure. This is not
     * set when the command is cancelled by the caller.
     */
    errorCode: string;
    /**
     * For commands of type RESET_PASSWORD, optionally specifies the new password.
     */
    newPassword: string;
    /**
     * For commands of type RESET_PASSWORD, optionally specifies flags.
     */
    resetPasswordFlags: string[];
    /**
     * The type of the command.
     */
    type: string;
    /**
     * 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.
     */
    userName: string;
}
/**
 * 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.
 */
export interface Schema$ComplianceRule {
    /**
     * A condition which is satisfied if the Android Framework API level on the
     * device doesn't meet a minimum requirement.
     */
    apiLevelCondition: Schema$ApiLevelCondition;
    /**
     * 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.
     */
    disableApps: boolean;
    /**
     * A condition which is satisfied if there exists any matching
     * NonComplianceDetail for the device.
     */
    nonComplianceDetailCondition: Schema$NonComplianceDetailCondition;
}
/**
 * A device owned by an enterprise. Unless otherwise noted, all fields are
 * read-only and can't be modified by enterprises.devices.patch.
 */
export interface Schema$Device {
    /**
     * The API level of the Android platform version running on the device.
     */
    apiLevel: number;
    /**
     * The name of the policy currently applied to the device.
     */
    appliedPolicyName: string;
    /**
     * The version of the policy currently applied to the device.
     */
    appliedPolicyVersion: string;
    /**
     * The state currently applied to the device.
     */
    appliedState: string;
    /**
     * Device settings information. This information is only available if
     * deviceSettingsEnabled is true in the device's policy.
     */
    deviceSettings: Schema$DeviceSettings;
    /**
     * If the device state is DISABLED, an optional message that is displayed on
     * the device indicating the reason the device is disabled. This field can be
     * modified by a patch request.
     */
    disabledReason: Schema$UserFacingMessage;
    /**
     * Detailed information about displays on the device. This information is only
     * available if displayInfoEnabled is true in the device's policy.
     */
    displays: Schema$Display[];
    /**
     * The time of device enrollment.
     */
    enrollmentTime: string;
    /**
     * If the device was enrolled with an enrollment token with additional data
     * provided, this field contains that data.
     */
    enrollmentTokenData: string;
    /**
     * If the device was enrolled with an enrollment token, this field contains
     * the name of the token.
     */
    enrollmentTokenName: string;
    /**
     * Detailed information about the device hardware.
     */
    hardwareInfo: Schema$HardwareInfo;
    /**
     * Hardware status samples in chronological order. This information is only
     * available if hardwareStatusEnabled is true in the device's policy.
     */
    hardwareStatusSamples: Schema$HardwareStatus[];
    /**
     * The last time the device sent a policy compliance report.
     */
    lastPolicyComplianceReportTime: string;
    /**
     * The last time the device fetched its policy.
     */
    lastPolicySyncTime: string;
    /**
     * The last time the device sent a status report.
     */
    lastStatusReportTime: string;
    /**
     * Events related to memory and storage measurements in chronological order.
     * This information is only available if memoryInfoEnabled is true in the
     * device's policy.
     */
    memoryEvents: Schema$MemoryEvent[];
    /**
     * Memory information. This information is only available if memoryInfoEnabled
     * is true in the device's policy.
     */
    memoryInfo: Schema$MemoryInfo;
    /**
     * The name of the device in the form
     * enterprises/{enterpriseId}/devices/{deviceId}.
     */
    name: string;
    /**
     * Device network information. This information is only available if
     * networkInfoEnabled is true in the device's policy.
     */
    networkInfo: Schema$NetworkInfo;
    /**
     * Details about policy settings that the device is not compliant with.
     */
    nonComplianceDetails: Schema$NonComplianceDetail[];
    /**
     * Whether the device is compliant with its policy.
     */
    policyCompliant: boolean;
    /**
     * 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.
     */
    policyName: string;
    /**
     * Power management events on the device in chronological order. This
     * information is only available if powerManagementEventsEnabled is true in
     * the device's policy.
     */
    powerManagementEvents: Schema$PowerManagementEvent[];
    /**
     * 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.
     */
    previousDeviceNames: string[];
    /**
     * Detailed information about the device software. This information is only
     * available if softwareInfoEnabled is true in the device's policy.
     */
    softwareInfo: Schema$SoftwareInfo;
    /**
     * 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.
     */
    state: string;
    /**
     * The resource name of the user that owns this device in the form
     * enterprises/{enterpriseId}/users/{userId}.
     */
    userName: string;
}
/**
 * Information about security related device settings on device.
 */
export interface Schema$DeviceSettings {
    /**
     * Whether ADB (https://developer.android.com/studio/command-line/adb.html) is
     * enabled on the device.
     */
    adbEnabled: boolean;
    /**
     * Whether developer mode is enabled on the device.
     */
    developmentSettingsEnabled: boolean;
    /**
     * Encryption status from DevicePolicyManager.
     */
    encryptionStatus: string;
    /**
     * Whether the device is secured with PIN/password.
     */
    isDeviceSecure: boolean;
    /**
     * Whether the storage encryption is enabled.
     */
    isEncrypted: boolean;
    /**
     * Whether installing apps from unknown sources is enabled.
     */
    unknownSourcesEnabled: boolean;
    /**
     * Whether Verify Apps (Google Play Protect
     * (https://support.google.com/googleplay/answer/2812853)) is enabled on the
     * device.
     */
    verifyAppsEnabled: boolean;
}
/**
 * Device display information.
 */
export interface Schema$Display {
    /**
     * Display density expressed as dots-per-inch.
     */
    density: number;
    /**
     * Unique display id.
     */
    displayId: number;
    /**
     * Display height in pixels.
     */
    height: number;
    /**
     * Name of the display.
     */
    name: string;
    /**
     * Refresh rate of the display in frames per second.
     */
    refreshRate: number;
    /**
     * State of the display.
     */
    state: string;
    /**
     * Display width in pixels.
     */
    width: number;
}
/**
 * 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 {}.
 */
export interface Schema$Empty {
}
/**
 * An enrollment token.
 */
export interface Schema$EnrollmentToken {
    /**
     * 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.
     */
    additionalData: string;
    /**
     * 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.
     */
    duration: string;
    /**
     * The expiration time of the token. This is a read-only field generated by
     * the server.
     */
    expirationTimestamp: string;
    /**
     * The name of the enrollment token, which is generated by the server during
     * creation, in the form
     * enterprises/{enterpriseId}/enrollmentTokens/{enrollmentTokenId}.
     */
    name: string;
    /**
     * 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.
     */
    policyName: string;
    /**
     * 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.
     */
    qrCode: string;
    /**
     * 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.
     */
    value: string;
}
/**
 * The configuration applied to an enterprise.
 */
export interface Schema$Enterprise {
    /**
     * Whether permissions for apps installed via policy are automatically
     * approved. If enabled, you must display an app's permissions to the
     * enterprise admin before setting the app to be installed in a policy.
     */
    appAutoApprovalEnabled: boolean;
    /**
     * The types of Google Pub/Sub notifications enabled for the enterprise.
     */
    enabledNotificationTypes: string[];
    /**
     * The name of the enterprise displayed to users.
     */
    enterpriseDisplayName: string;
    /**
     * An image displayed as a logo during device provisioning. Supported types
     * are: image/bmp, image/gif, image/x-ico, image/jpeg, image/png, image/webp,
     * image/vnd.wap.wbmp, image/x-adobe-dng.
     */
    logo: Schema$ExternalData;
    /**
     * The name of the enterprise which is generated by the server during
     * creation, in the form enterprises/{enterpriseId}.
     */
    name: string;
    /**
     * 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.
     */
    primaryColor: number;
    /**
     * 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.
     */
    pubsubTopic: string;
}
/**
 * Data hosted at an external location. The data is to be downloaded by Android
 * Device Policy and verified against the hash.
 */
export interface Schema$ExternalData {
    /**
     * 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.
     */
    sha256Hash: string;
    /**
     * 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.
     */
    url: string;
}
/**
 * Information about device hardware. The fields related to temperature
 * thresholds are only available if hardwareStatusEnabled is true in the
 * device's policy.
 */
export interface Schema$HardwareInfo {
    /**
     * Battery shutdown temperature thresholds in Celsius for each battery on the
     * device.
     */
    batteryShutdownTemperatures: number[];
    /**
     * Battery throttling temperature thresholds in Celsius for each battery on
     * the device.
     */
    batteryThrottlingTemperatures: number[];
    /**
     * Brand of the device. For example, Google.
     */
    brand: string;
    /**
     * CPU shutdown temperature thresholds in Celsius for each CPU on the device.
     */
    cpuShutdownTemperatures: number[];
    /**
     * CPU throttling temperature thresholds in Celsius for each CPU on the
     * device.
     */
    cpuThrottlingTemperatures: number[];
    /**
     * Baseband version. For example, MDM9625_104662.22.05.34p.
     */
    deviceBasebandVersion: string;
    /**
     * GPU shutdown temperature thresholds in Celsius for each GPU on the device.
     */
    gpuShutdownTemperatures: number[];
    /**
     * GPU throttling temperature thresholds in Celsius for each GPU on the
     * device.
     */
    gpuThrottlingTemperatures: number[];
    /**
     * Name of the hardware. For example, Angler.
     */
    hardware: string;
    /**
     * Manufacturer. For example, Motorola.
     */
    manufacturer: string;
    /**
     * The model of the device. For example, Asus Nexus 7.
     */
    model: string;
    /**
     * The device serial number.
     */
    serialNumber: string;
    /**
     * Device skin shutdown temperature thresholds in Celsius.
     */
    skinShutdownTemperatures: number[];
    /**
     * Device skin throttling temperature thresholds in Celsius.
     */
    skinThrottlingTemperatures: number[];
}
/**
 * Hardware status. Temperatures may be compared to the temperature thresholds
 * available in hardwareInfo to determine hardware health.
 */
export interface Schema$HardwareStatus {
    /**
     * Current battery temperatures in Celsius for each battery on the device.
     */
    batteryTemperatures: number[];
    /**
     * Current CPU temperatures in Celsius for each CPU on the device.
     */
    cpuTemperatures: number[];
    /**
     * 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.
     */
    cpuUsages: number[];
    /**
     * The time the measurements were taken.
     */
    createTime: string;
    /**
     * 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.
     */
    fanSpeeds: number[];
    /**
     * Current GPU temperatures in Celsius for each GPU on the device.
     */
    gpuTemperatures: number[];
    /**
     * Current device skin temperatures in Celsius.
     */
    skinTemperatures: number[];
}
/**
 * Response to a request to list devices for a given enterprise.
 */
export interface Schema$ListDevicesResponse {
    /**
     * The list of devices.
     */
    devices: Schema$Device[];
    /**
     * If there are more results, a token to retrieve next page of results.
     */
    nextPageToken: string;
}
/**
 * The response message for Operations.ListOperations.
 */
export interface Schema$ListOperationsResponse {
    /**
     * The standard List next-page token.
     */
    nextPageToken: string;
    /**
     * A list of operations that matches the specified filter in the request.
     */
    operations: Schema$Operation[];
}
/**
 * Response to a request to list policies for a given enterprise.
 */
export interface Schema$ListPoliciesResponse {
    /**
     * If there are more results, a token to retrieve next page of results.
     */
    nextPageToken: string;
    /**
     * The list of policies.
     */
    policies: Schema$Policy[];
}
/**
 * Managed property.
 */
export interface Schema$ManagedProperty {
    /**
     * The default value of the property. BUNDLE_ARRAY properties don't have a
     * default value.
     */
    defaultValue: any;
    /**
     * A longer description of the property, providing more detail of what it
     * affects. Localized.
     */
    description: string;
    /**
     * For CHOICE or MULTISELECT properties, the list of possible entries.
     */
    entries: Schema$ManagedPropertyEntry[];
    /**
     * The unique key that the app uses to identify the property, e.g.
     * "com.google.android.gm.fieldname".
     */
    key: string;
    /**
     * For BUNDLE_ARRAY properties, the list of nested properties. A BUNDLE_ARRAY
     * property is at most two levels deep.
     */
    nestedProperties: Schema$ManagedProperty[];
    /**
     * The name of the property. Localized.
     */
    title: string;
    /**
     * The type of the property.
     */
    type: string;
}
/**
 * An entry of a managed property.
 */
export interface Schema$ManagedPropertyEntry {
    /**
     * The human-readable name of the value. Localized.
     */
    name: string;
    /**
     * The machine-readable value of the entry, which should be used in the
     * configuration. Not localized.
     */
    value: string;
}
/**
 * An event related to memory and storage measurements.
 */
export interface Schema$MemoryEvent {
    /**
     * The number of free bytes in the medium, or for EXTERNAL_STORAGE_DETECTED,
     * the total capacity in bytes of the storage medium.
     */
    byteCount: string;
    /**
     * The creation time of the event.
     */
    createTime: string;
    /**
     * Event type.
     */
    eventType: string;
}
/**
 * Information about device memory and storage.
 */
export interface Schema$MemoryInfo {
    /**
     * Total internal storage on device in bytes.
     */
    totalInternalStorage: string;
    /**
     * Total RAM on device in bytes.
     */
    totalRam: string;
}
/**
 * Device network info.
 */
export interface Schema$NetworkInfo {
    /**
     * IMEI number of the GSM device. For example, A1000031212.
     */
    imei: string;
    /**
     * MEID number of the CDMA device. For example, A00000292788E1.
     */
    meid: string;
    /**
     * Alphabetic name of current registered operator. For example, Vodafone.
     */
    networkOperatorName: string;
    /**
     * Wi-Fi MAC address of the device. For example, 7c:11:11:11:11:11.
     */
    wifiMacAddress: string;
}
/**
 * Provides detail about non-compliance with a policy setting.
 */
export interface Schema$NonComplianceDetail {
    /**
     * If the policy setting could not be applied, the current value of the
     * setting on the device.
     */
    currentValue: any;
    /**
     * 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
     */
    fieldPath: string;
    /**
     * 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.
     */
    installationFailureReason: string;
    /**
     * The reason the device is not in compliance with the setting.
     */
    nonComplianceReason: string;
    /**
     * The package name indicating which app is out of compliance, if applicable.
     */
    packageName: string;
    /**
     * The name of the policy setting. This is the JSON field name of a top-level
     * Policy  field.
     */
    settingName: string;
}
/**
 * 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.
 */
export interface Schema$NonComplianceDetailCondition {
    /**
     * The reason the device is not in compliance with the setting. If not set,
     * then this condition matches any reason.
     */
    nonComplianceReason: string;
    /**
     * The package name of the app that's out of compliance. If not set, then
     * this condition matches any package name.
     */
    packageName: string;
    /**
     * 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.
     */
    settingName: string;
}
/**
 * This resource represents a long-running operation that is the result of a
 * network API call.
 */
export interface Schema$Operation {
    /**
     * 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.
     */
    done: boolean;
    /**
     * The error result of the operation in case of failure or cancellation.
     */
    error: Schema$Status;
    /**
     * 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.
     */
    metadata: any;
    /**
     * 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
     * have the format of operations/some/unique/name.
     */
    name: string;
    /**
     * 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.
     */
    response: any;
}
/**
 * A list of package names.
 */
export interface Schema$PackageNameList {
    /**
     * A list of package names.
     */
    packageNames: string[];
}
/**
 * Requirements for the password used to unlock a device.
 */
export interface Schema$PasswordRequirements {
    /**
     * Number of incorrect device-unlock passwords that can be entered before a
     * device is wiped. A value of 0 means there is no restriction.
     */
    maximumFailedPasswordsForWipe: number;
    /**
     * Password expiration timeout.
     */
    passwordExpirationTimeout: string;
    /**
     * 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.
     */
    passwordHistoryLength: number;
    /**
     * 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.
     */
    passwordMinimumLength: number;
    /**
     * Minimum number of letters required in the password. Only enforced when
     * password_quality is COMPLEX.
     */
    passwordMinimumLetters: number;
    /**
     * Minimum number of lower case letters required in the password. Only
     * enforced when password_quality is COMPLEX.
     */
    passwordMinimumLowerCase: number;
    /**
     * Minimum number of non-letter characters (numerical digits or symbols)
     * required in the password. Only enforced when password_quality is COMPLEX.
     */
    passwordMinimumNonLetter: number;
    /**
     * Minimum number of numerical digits required in the password. Only enforced
     * when password_quality is COMPLEX.
     */
    passwordMinimumNumeric: number;
    /**
     * Minimum number of symbols required in the password. Only enforced when
     * password_quality is COMPLEX.
     */
    passwordMinimumSymbols: number;
    /**
     * Minimum number of upper case letters required in the password. Only
     * enforced when password_quality is COMPLEX.
     */
    passwordMinimumUpperCase: number;
    /**
     * The required password quality.
     */
    passwordQuality: string;
}
/**
 * Configuration for an Android permission and its grant state.
 */
export interface Schema$PermissionGrant {
    /**
     * The android permission, e.g. android.permission.READ_CALENDAR.
     */
    permission: string;
    /**
     * The policy for granting the permission.
     */
    policy: string;
}
/**
 * A default activity for handling intents that match a particular intent
 * filter.
 */
export interface Schema$PersistentPreferredActivity {
    /**
     * 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.
     */
    actions: string[];
    /**
     * 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.
     */
    categories: string[];
    /**
     * 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.
     */
    receiverActivity: string;
}
/**
 * A policy resources represents a group settings that govern the behavior of a
 * managed device and the apps installed on it.
 */
export interface Schema$Policy {
    /**
     * Account types that can't be managed by the user.
     */
    accountTypesWithManagementDisabled: string[];
    /**
     * Whether adding new users and profiles is disabled.
     */
    addUserDisabled: boolean;
    /**
     * Whether adjusting the master volume is disabled.
     */
    adjustVolumeDisabled: boolean;
    /**
     * Configuration for an always-on VPN connection. Use with vpn_config_disabled
     * to prevent modification of this setting.
     */
    alwaysOnVpnPackage: Schema$AlwaysOnVpnPackage;
    /**
     * 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.
     */
    androidDevicePolicyTracks: string[];
    /**
     * The app auto update policy, which controls when automatic app updates can
     * be applied.
     */
    appAutoUpdatePolicy: string;
    /**
     * Policy applied to apps.
     */
    applications: Schema$ApplicationPolicy[];
    /**
     * Whether auto time is required, which prevents the user from manually
     * setting the date and time.
     */
    autoTimeRequired: boolean;
    /**
     * 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.
     */
    blockApplicationsEnabled: boolean;
    /**
     * Whether configuring bluetooth is disabled.
     */
    bluetoothConfigDisabled: boolean;
    /**
     * Whether bluetooth contact sharing is disabled.
     */
    bluetoothContactSharingDisabled: boolean;
    /**
     * Whether bluetooth is disabled. Prefer this setting over
     * bluetooth_config_disabled because bluetooth_config_disabled can be bypassed
     * by the user.
     */
    bluetoothDisabled: boolean;
    /**
     * Whether all cameras on the device are disabled.
     */
    cameraDisabled: boolean;
    /**
     * Whether configuring cell broadcast is disabled.
     */
    cellBroadcastsConfigDisabled: boolean;
    /**
     * 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.
     */
    complianceRules: Schema$ComplianceRule[];
    /**
     * Whether creating windows besides app windows is disabled.
     */
    createWindowsDisabled: boolean;
    /**
     * Whether configuring user credentials is disabled.
     */
    credentialsConfigDisabled: boolean;
    /**
     * Whether roaming data services are disabled.
     */
    dataRoamingDisabled: boolean;
    /**
     * Whether the user is allowed to enable debugging features.
     */
    debuggingFeaturesAllowed: boolean;
    /**
     * The default permission policy for runtime permission requests.
     */
    defaultPermissionPolicy: string;
    /**
     * The device owner information to be shown on the lock screen.
     */
    deviceOwnerLockScreenInfo: Schema$UserFacingMessage;
    /**
     * Whether encryption is enabled
     */
    encryptionPolicy: string;
    /**
     * Whether app verification is force-enabled.
     */
    ensureVerifyAppsEnabled: boolean;
    /**
     * Whether factory resetting from settings is disabled.
     */
    factoryResetDisabled: boolean;
    /**
     * 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.
     */
    frpAdminEmails: string[];
    /**
     * Whether the user is allowed to have fun. Controls whether the Easter egg
     * game in Settings is disabled.
     */
    funDisabled: boolean;
    /**
     * Whether user installation of apps is disabled.
     */
    installAppsDisabled: boolean;
    /**
     * Whether the user is allowed to enable the "Unknown Sources"
     * setting, which allows installation of apps from unknown sources.
     */
    installUnknownSourcesAllowed: boolean;
    /**
     * Whether the keyguard is disabled.
     */
    keyguardDisabled: boolean;
    /**
     * Disabled keyguard customizations, such as widgets.
     */
    keyguardDisabledFeatures: string[];
    /**
     * 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. The apps appear on a single page in alphabetical
     * order. It is recommended to also use status_bar_disabled to block access to
     * device settings.
     */
    kioskCustomLauncherEnabled: boolean;
    /**
     * The degree of location detection enabled. The user may change the value
     * unless the user is otherwise blocked from accessing device settings.
     */
    locationMode: string;
    /**
     * A message displayed to the user in the device administators settings
     * screen.
     */
    longSupportMessage: Schema$UserFacingMessage;
    /**
     * Maximum time in milliseconds for user activity until the device locks. A
     * value of 0 means there is no restriction.
     */
    maximumTimeToLock: string;
    /**
     * Whether configuring mobile networks is disabled.
     */
    mobileNetworksConfigDisabled: boolean;
    /**
     * Whether adding or removing accounts is disabled.
     */
    modifyAccountsDisabled: boolean;
    /**
     * Whether the user mounting physical external media is disabled.
     */
    mountPhysicalMediaDisabled: boolean;
    /**
     * The name of the policy in the form
     * enterprises/{enterpriseId}/policies/{policyId}.
     */
    name: string;
    /**
     * 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.
     */
    networkEscapeHatchEnabled: boolean;
    /**
     * Whether resetting network settings is disabled.
     */
    networkResetDisabled: boolean;
    /**
     * Network configuration for the device. See configure networks for more
     * information.
     */
    openNetworkConfiguration: any;
    /**
     * Whether using NFC to beam data from apps is disabled.
     */
    outgoingBeamDisabled: boolean;
    /**
     * Whether outgoing calls are disabled.
     */
    outgoingCallsDisabled: boolean;
    /**
     * Password requirements.
     */
    passwordRequirements: Schema$PasswordRequirements;
    /**
     * If present, only the input methods provided by packages in this list are
     * permitted. If this field is present, but the list is empty, then only
     * system input methods are permitted.
     */
    permittedInputMethods: Schema$PackageNameList;
    /**
     * Default intent handler activities.
     */
    persistentPreferredActivities: Schema$PersistentPreferredActivity[];
    /**
     * The network-independent global HTTP proxy. Typically proxies should be
     * configured per-network in open_network_configuration. However for unusual
     * configurations like general internal filtering a global HTTP proxy may be
     * useful. If the proxy is not accessible, network access may break. The
     * global proxy is only a recommendation and some apps may ignore it.
     */
    recommendedGlobalProxy: Schema$ProxyInfo;
    /**
     * Whether removing other users is disabled.
     */
    removeUserDisabled: boolean;
    /**
     * Whether rebooting the device into safe boot is disabled.
     */
    safeBootDisabled: boolean;
    /**
     * Whether screen capture is disabled.
     */
    screenCaptureDisabled: boolean;
    /**
     * Whether changing the user icon is disabled.
     */
    setUserIconDisabled: boolean;
    /**
     * Whether changing the wallpaper is disabled.
     */
    setWallpaperDisabled: boolean;
    /**
     * Whether location sharing is disabled.
     */
    shareLocationDisabled: boolean;
    /**
     * A message displayed to the user in the settings screen wherever
     * functionality has been disabled by the admin.
     */
    shortSupportMessage: Schema$UserFacingMessage;
    /**
     * 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.
     */
    skipFirstUseHintsEnabled: boolean;
    /**
     * Whether sending and receiving SMS messages is disabled.
     */
    smsDisabled: boolean;
    /**
     * Whether the status bar is disabled. This disables notifications, quick
     * settings, and other screen overlays that allow escape from full-screen
     * mode.
     */
    statusBarDisabled: boolean;
    /**
     * Status reporting settings
     */
    statusReportingSettings: Schema$StatusReportingSettings;
    /**
     * 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.
     */
    stayOnPluggedModes: string[];
    /**
     * The system update policy, which controls how OS updates are applied. If the
     * update type is WINDOWED, the update window will automatically apply to Play
     * app updates as well.
     */
    systemUpdate: Schema$SystemUpdate;
    /**
     * Whether configuring tethering and portable hotspots is disabled.
     */
    tetheringConfigDisabled: boolean;
    /**
     * Whether user uninstallation of applications is disabled.
     */
    uninstallAppsDisabled: boolean;
    /**
     * Whether the microphone is muted and adjusting microphone volume is
     * disabled.
     */
    unmuteMicrophoneDisabled: boolean;
    /**
     * Whether transferring files over USB is disabled.
     */
    usbFileTransferDisabled: boolean;
    /**
     * Allows admins to toggle whether USB storge is enabled or disabled on
     * user's devices. Next ID: 114
     */
    usbMassStorageEnabled: boolean;
    /**
     * The version of the policy. This is a read-only field. The version is
     * incremented each time the policy is updated.
     */
    version: string;
    /**
     * Whether configuring VPN is disabled.
     */
    vpnConfigDisabled: boolean;
    /**
     * Whether configuring Wi-Fi access points is disabled.
     */
    wifiConfigDisabled: boolean;
    /**
     * Whether Wi-Fi networks defined in Open Network Configuration are locked so
     * they can't be edited by the user.
     */
    wifiConfigsLockdownEnabled: boolean;
}
/**
 * A power management event.
 */
export interface Schema$PowerManagementEvent {
    /**
     * For BATTERY_LEVEL_COLLECTED events, the battery level as a percentage.
     */
    batteryLevel: number;
    /**
     * The creation time of the event.
     */
    createTime: string;
    /**
     * Event type.
     */
    eventType: string;
}
/**
 * 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.
 */
export interface Schema$ProxyInfo {
    /**
     * For a direct proxy, the hosts for which the proxy is bypassed. The host
     * names may contain wildcards such as *.example.com.
     */
    excludedHosts: string[];
    /**
     * The host of the direct proxy.
     */
    host: string;
    /**
     * The URI of the PAC script used to configure the proxy.
     */
    pacUri: string;
    /**
     * The port of the direct proxy.
     */
    port: number;
}
/**
 * An enterprise signup URL.
 */
export interface Schema$SignupUrl {
    /**
     * The name of the resource. Use this value in the signupUrl field when
     * calling enterprises.create to complete the enterprise signup flow.
     */
    name: string;
    /**
     * A URL where an enterprise admin can register their enterprise. The page
     * can't be rendered in an iframe.
     */
    url: string;
}
/**
 * Information about device software.
 */
export interface Schema$SoftwareInfo {
    /**
     * Android build ID string meant for displaying to the user. For example,
     * shamu-userdebug 6.0.1 MOB30I 2756745 dev-keys.
     */
    androidBuildNumber: string;
    /**
     * Build time.
     */
    androidBuildTime: string;
    /**
     * The Android Device Policy app version code.
     */
    androidDevicePolicyVersionCode: number;
    /**
     * The Android Device Policy app version as displayed to the user.
     */
    androidDevicePolicyVersionName: string;
    /**
     * The user-visible Android version string. For example, 6.0.1.
     */
    androidVersion: string;
    /**
     * The system bootloader version number, e.g. 0.6.7.
     */
    bootloaderVersion: string;
    /**
     * 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.
     */
    deviceBuildSignature: string;
    /**
     * Kernel version, for example, 2.6.32.9-g103d848.
     */
    deviceKernelVersion: string;
    /**
     * Security patch level, e.g. 2016-05-01.
     */
    securityPatchLevel: string;
}
/**
 * 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). The error model is designed to be: Simple to
 * use and understand for most users Flexible enough to meet unexpected
 * needsOverviewThe Status message contains three pieces of data: error code,
 * error message, and error details. The error code should be an enum value of
 * google.rpc.Code, but it may accept additional error codes if needed. The
 * error message should be a developer-facing English message that helps
 * developers understand and resolve the error. If a localized user-facing error
 * message is needed, put the localized message in the error details or localize
 * it in the client. The optional error details may contain arbitrary
 * information about the error. There is a predefined set of error detail types
 * in the package google.rpc that can be used for common error
 * conditions.Language mappingThe Status message is the logical representation
 * of the error model, but it is not necessarily the actual wire format. When
 * the Status message is exposed in different client libraries and different
 * wire protocols, it can be mapped differently. For example, it will likely be
 * mapped to some exceptions in Java, but more likely mapped to some error codes
 * in C.Other usesThe error model and the Status message can be used in a
 * variety of environments, either with or without APIs, to provide a consistent
 * developer experience across different environmen