googleapis/build/src/apis/androidenterprise/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';
/**
 * Google Play EMM API
 *
 * Manages the deployment of apps to Android for Work users.
 *
 * @example
 * const google = require('googleapis');
 * const androidenterprise = google.androidenterprise('v1');
 *
 * @namespace androidenterprise
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for Androidenterprise
 */
export declare class Androidenterprise {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    devices: Resource$Devices;
    enterprises: Resource$Enterprises;
    entitlements: Resource$Entitlements;
    grouplicenses: Resource$Grouplicenses;
    grouplicenseusers: Resource$Grouplicenseusers;
    installs: Resource$Installs;
    managedconfigurationsfordevice: Resource$Managedconfigurationsfordevice;
    managedconfigurationsforuser: Resource$Managedconfigurationsforuser;
    managedconfigurationssettings: Resource$Managedconfigurationssettings;
    permissions: Resource$Permissions;
    products: Resource$Products;
    serviceaccountkeys: Resource$Serviceaccountkeys;
    storelayoutclusters: Resource$Storelayoutclusters;
    storelayoutpages: Resource$Storelayoutpages;
    users: Resource$Users;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * This represents an enterprise admin who can manage the enterprise in the
 * managed Google Play store.
 */
export interface Schema$Administrator {
    /**
     * The admin's email address.
     */
    email: string;
}
/**
 * A token authorizing an admin to access an iframe.
 */
export interface Schema$AdministratorWebToken {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#administratorWebToken".
     */
    kind: string;
    /**
     * An opaque token to be passed to the Play front-end to generate an iframe.
     */
    token: string;
}
/**
 * Specification for a token used to generate iframes. The token specifies what
 * data the admin is allowed to modify and the URI the iframe is allowed to
 * communiate with.
 */
export interface Schema$AdministratorWebTokenSpec {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#administratorWebTokenSpec".
     */
    kind: string;
    /**
     * The URI of the parent frame hosting the iframe. To prevent XSS, the iframe
     * may not be hosted at other URIs. This URI must be https.
     */
    parent: string;
    /**
     * The list of permissions the admin is granted within the iframe. The admin
     * will only be allowed to view an iframe if they have all of the permissions
     * associated with it. The only valid value is "approveApps" that
     * will allow the admin to access the iframe in "approve" mode.
     */
    permission: string[];
}
/**
 * The Android Device Policy configuration of an enterprise.
 */
export interface Schema$AndroidDevicePolicyConfig {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#androidDevicePolicyConfig".
     */
    kind: string;
    /**
     * The state of Android Device Policy. "enabled" indicates that
     * Android Device Policy is enabled for the enterprise and the EMM is allowed
     * to manage devices with Android Device Policy, while "disabled"
     * means that it cannot.
     */
    state: string;
}
/**
 * Represents the list of app restrictions available to be pre-configured for
 * the product.
 */
export interface Schema$AppRestrictionsSchema {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#appRestrictionsSchema".
     */
    kind: string;
    /**
     * The set of restrictions that make up this schema.
     */
    restrictions: Schema$AppRestrictionsSchemaRestriction[];
}
/**
 * An event generated when a new app version is uploaded to Google Play and its
 * app restrictions schema changed. To fetch the app restrictions schema for an
 * app, use Products.getAppRestrictionsSchema on the EMM API.
 */
export interface Schema$AppRestrictionsSchemaChangeEvent {
    /**
     * The id of the product (e.g. "app:com.google.android.gm") for
     * which the app restriction schema changed. This field will always be
     * present.
     */
    productId: string;
}
/**
 * A restriction in the App Restriction Schema represents a piece of
 * configuration that may be pre-applied.
 */
export interface Schema$AppRestrictionsSchemaRestriction {
    /**
     * The default value of the restriction. bundle and bundleArray restrictions
     * never have a default value.
     */
    defaultValue: Schema$AppRestrictionsSchemaRestrictionRestrictionValue;
    /**
     * A longer description of the restriction, giving more detail of what it
     * affects.
     */
    description: string;
    /**
     * For choice or multiselect restrictions, the list of possible entries'
     * human-readable names.
     */
    entry: string[];
    /**
     * For choice or multiselect restrictions, the list of possible entries'
     * machine-readable values. These values should be used in the configuration,
     * either as a single string value for a choice restriction or in a
     * stringArray for a multiselect restriction.
     */
    entryValue: string[];
    /**
     * The unique key that the product uses to identify the restriction, e.g.
     * "com.google.android.gm.fieldname".
     */
    key: string;
    /**
     * For bundle or bundleArray restrictions, the list of nested restrictions. A
     * bundle restriction is always nested within a bundleArray restriction, and a
     * bundleArray restriction is at most two levels deep.
     */
    nestedRestriction: Schema$AppRestrictionsSchemaRestriction[];
    /**
     * The type of the restriction.
     */
    restrictionType: string;
    /**
     * The name of the restriction.
     */
    title: string;
}
/**
 * A typed value for the restriction.
 */
export interface Schema$AppRestrictionsSchemaRestrictionRestrictionValue {
    /**
     * The type of the value being provided.
     */
    type: string;
    /**
     * The boolean value - this will only be present if type is bool.
     */
    valueBool: boolean;
    /**
     * The integer value - this will only be present if type is integer.
     */
    valueInteger: number;
    /**
     * The list of string values - this will only be present if type is
     * multiselect.
     */
    valueMultiselect: string[];
    /**
     * The string value - this will be present for types string, choice and
     * hidden.
     */
    valueString: string;
}
/**
 * Information on an approval URL.
 */
export interface Schema$ApprovalUrlInfo {
    /**
     * A URL that displays a product's permissions and that can also be used
     * to approve the product with the Products.approve call.
     */
    approvalUrl: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#approvalUrlInfo".
     */
    kind: string;
}
/**
 * An event generated when a new version of an app is uploaded to Google Play.
 * Notifications are sent for new public versions only: alpha, beta, or canary
 * versions do not generate this event. To fetch up-to-date version history for
 * an app, use Products.Get on the EMM API.
 */
export interface Schema$AppUpdateEvent {
    /**
     * The id of the product (e.g. "app:com.google.android.gm") that was
     * updated. This field will always be present.
     */
    productId: string;
}
/**
 * This represents a single version of the app.
 */
export interface Schema$AppVersion {
    /**
     * The track that this app was published in. For example if track is
     * "alpha", this is an alpha version of the app.
     */
    track: string;
    /**
     * Unique increasing identifier for the app version.
     */
    versionCode: number;
    /**
     * The string used in the Play store by the app developer to identify the
     * version. The string is not necessarily unique or localized (for example,
     * the string could be "1.4").
     */
    versionString: string;
}
/**
 * An AuthenticationToken is used by the EMM's device policy client on a
 * device to provision the given EMM-managed user on that device.
 */
export interface Schema$AuthenticationToken {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#authenticationToken".
     */
    kind: string;
    /**
     * The authentication token to be passed to the device policy client on the
     * device where it can be used to provision the account for which this token
     * was generated.
     */
    token: string;
}
/**
 * A configuration variables resource contains the managed configuration
 * settings ID to be applied to a single user, as well as the variable set that
 * is attributed to the user. The variable set will be used to replace
 * placeholders in the managed configuration settings.
 */
export interface Schema$ConfigurationVariables {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#configurationVariables".
     */
    kind: string;
    /**
     * The ID of the managed configurations settings.
     */
    mcmId: string;
    /**
     * The variable set that is attributed to the user.
     */
    variableSet: Schema$VariableSet[];
}
/**
 * A Devices resource represents a mobile device managed by the EMM and
 * belonging to a specific enterprise user.
 */
export interface Schema$Device {
    /**
     * The Google Play Services Android ID for the device encoded as a lowercase
     * hex string. For example, "123456789abcdef0".
     */
    androidId: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#device".
     */
    kind: string;
    /**
     * Identifies the extent to which the device is controlled by a managed Google
     * Play EMM in various deployment configurations.  Possible values include:  -
     * "managedDevice", a device that has the EMM's device policy
     * controller (DPC) as the device owner.  - "managedProfile", a
     * device that has a profile managed by the DPC (DPC is profile owner) in
     * addition to a separate, personal profile that is unavailable to the DPC.  -
     * "containerApp", no longer used (deprecated).  -
     * "unmanagedProfile", a device that has been allowed (by the
     * domain's admin, using the Admin Console to enable the privilege) to use
     * managed Google Play, but the profile is itself not owned by a DPC.
     */
    managementType: string;
    /**
     * The policy enforced on the device.
     */
    policy: Schema$Policy;
}
/**
 * The device resources for the user.
 */
export interface Schema$DevicesListResponse {
    /**
     * A managed device.
     */
    device: Schema$Device[];
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#devicesListResponse".
     */
    kind: string;
}
/**
 * The state of a user's device, as accessed by the getState and setState
 * methods on device resources.
 */
export interface Schema$DeviceState {
    /**
     * The state of the Google account on the device. "enabled"
     * indicates that the Google account on the device can be used to access
     * Google services (including Google Play), while "disabled" means
     * that it cannot. A new device is initially in the "disabled"
     * state.
     */
    accountState: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#deviceState".
     */
    kind: string;
}
/**
 * An Enterprises resource represents the binding between an EMM and a specific
 * organization. That binding can be instantiated in one of two different ways
 * using this API as follows:  - For Google managed domain customers, the
 * process involves using Enterprises.enroll and Enterprises.setAccount (in
 * conjunction with artifacts obtained from the Admin console and the Google API
 * Console) and submitted to the EMM through a more-or-less manual process.  -
 * For managed Google Play Accounts customers, the process involves using
 * Enterprises.generateSignupUrl and Enterprises.completeSignup in conjunction
 * with the managed Google Play sign-up UI (Google-provided mechanism) to create
 * the binding without manual steps. As an EMM, you can support either or both
 * approaches in your EMM console. See Create an Enterprise for details.
 */
export interface Schema$Enterprise {
    /**
     * Admins of the enterprise. This is only supported for enterprises created
     * via the EMM-initiated flow.
     */
    administrator: Schema$Administrator[];
    /**
     * The unique ID for the enterprise.
     */
    id: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#enterprise".
     */
    kind: string;
    /**
     * The name of the enterprise, for example, "Example, Inc".
     */
    name: string;
    /**
     * The enterprise's primary domain, such as "example.com".
     */
    primaryDomain: string;
}
/**
 * A service account that can be used to authenticate as the enterprise to API
 * calls that require such authentication.
 */
export interface Schema$EnterpriseAccount {
    /**
     * The email address of the service account.
     */
    accountEmail: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#enterpriseAccount".
     */
    kind: string;
}
/**
 * The matching enterprise resources.
 */
export interface Schema$EnterprisesListResponse {
    /**
     * An enterprise.
     */
    enterprise: Schema$Enterprise[];
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#enterprisesListResponse".
     */
    kind: string;
}
export interface Schema$EnterprisesSendTestPushNotificationResponse {
    /**
     * The message ID of the test push notification that was sent.
     */
    messageId: string;
    /**
     * The name of the Cloud Pub/Sub topic to which notifications for this
     * enterprise's enrolled account will be sent.
     */
    topicName: string;
}
/**
 * The presence of an Entitlements resource indicates that a user has the right
 * to use a particular app. Entitlements are user specific, not device specific.
 * This allows a user with an entitlement to an app to install the app on all
 * their devices. It's also possible for a user to hold an entitlement to an
 * app without installing the app on any device.  The API can be used to create
 * an entitlement. As an option, you can also use the API to trigger the
 * installation of an app on all a user's managed devices at the same time
 * the entitlement is created.  If the app is free, creating the entitlement
 * also creates a group license for that app. For paid apps, creating the
 * entitlement consumes one license, and that license remains consumed until the
 * entitlement is removed. If the enterprise hasn't purchased enough
 * licenses, then no entitlement is created and the installation fails. An
 * entitlement is also not created for an app if the app requires permissions
 * that the enterprise hasn't accepted.  If an entitlement is deleted, the
 * app may be uninstalled from a user's device. As a best practice,
 * uninstall the app by calling  Installs.delete() before deleting the
 * entitlement.  Entitlements for apps that a user pays for on an unmanaged
 * profile have "userPurchase" as the entitlement reason. These
 * entitlements cannot be removed via the API.
 */
export interface Schema$Entitlement {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#entitlement".
     */
    kind: string;
    /**
     * The ID of the product that the entitlement is for. For example,
     * "app:com.google.android.gm".
     */
    productId: string;
    /**
     * The reason for the entitlement. For example, "free" for free
     * apps. This property is temporary: it will be replaced by the acquisition
     * kind field of group licenses.
     */
    reason: string;
}
/**
 * The entitlement resources for the user.
 */
export interface Schema$EntitlementsListResponse {
    /**
     * An entitlement of a user to a product (e.g. an app). For example, a free
     * app that they have installed, or a paid app that they have been allocated a
     * license to.
     */
    entitlement: Schema$Entitlement[];
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#entitlementsListResponse".
     */
    kind: string;
}
/**
 * Group license objects allow you to keep track of licenses (called
 * entitlements) for both free and paid apps. For a free app, a group license is
 * created when an enterprise admin first approves the product in Google Play or
 * when the first entitlement for the product is created for a user via the API.
 * For a paid app, a group license object is only created when an enterprise
 * admin purchases the product in Google Play for the first time.  Use the API
 * to query group licenses. A Grouplicenses resource includes the total number
 * of licenses purchased (paid apps only) and the total number of licenses
 * currently in use. In other words, the total number of Entitlements that exist
 * for the product.  Only one group license object is created per product and
 * group license objects are never deleted. If a product is unapproved, its
 * group license remains. This allows enterprise admins to keep track of any
 * remaining entitlements for the product.
 */
export interface Schema$GroupLicense {
    /**
     * How this group license was acquired. "bulkPurchase" means that
     * this Grouplicenses resource was created because the enterprise purchased
     * licenses for this product; otherwise, the value is "free" (for
     * free products).
     */
    acquisitionKind: string;
    /**
     * Whether the product to which this group license relates is currently
     * approved by the enterprise. Products are approved when a group license is
     * first created, but this approval may be revoked by an enterprise admin via
     * Google Play. Unapproved products will not be visible to end users in
     * collections, and new entitlements to them should not normally be created.
     */
    approval: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#groupLicense".
     */
    kind: string;
    /**
     * The total number of provisioned licenses for this product. Returned by read
     * operations, but ignored in write operations.
     */
    numProvisioned: number;
    /**
     * The number of purchased licenses (possibly in multiple purchases). If this
     * field is omitted, then there is no limit on the number of licenses that can
     * be provisioned (for example, if the acquisition kind is "free").
     */
    numPurchased: number;
    /**
     * The permission approval status of the product. This field is only set if
     * the product is approved. Possible states are:  -
     * "currentApproved", the current set of permissions is approved,
     * but additional permissions will require the administrator to reapprove the
     * product (If the product was approved without specifying the approved
     * permissions setting, then this is the default behavior.),  -
     * "needsReapproval", the product has unapproved permissions. No
     * additional product licenses can be assigned until the product is
     * reapproved,  - "allCurrentAndFutureApproved", the current
     * permissions are approved and any future permission updates will be
     * automatically approved without administrator review.
     */
    permissions: string;
    /**
     * The ID of the product that the license is for. For example,
     * "app:com.google.android.gm".
     */
    productId: string;
}
/**
 * The grouplicense resources for the enterprise.
 */
export interface Schema$GroupLicensesListResponse {
    /**
     * A group license for a product approved for use in the enterprise.
     */
    groupLicense: Schema$GroupLicense[];
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#groupLicensesListResponse".
     */
    kind: string;
}
/**
 * The user resources for the group license.
 */
export interface Schema$GroupLicenseUsersListResponse {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#groupLicenseUsersListResponse".
     */
    kind: string;
    /**
     * A user of an enterprise.
     */
    user: Schema$User[];
}
/**
 * The existence of an Installs resource indicates that an app is installed on a
 * particular device (or that an install is pending).  The API can be used to
 * create an install resource using the update method. This triggers the actual
 * install of the app on the device. If the user does not already have an
 * entitlement for the app, then an attempt is made to create one. If this fails
 * (for example, because the app is not free and there is no available license),
 * then the creation of the install fails.  The API can also be used to update
 * an installed app. If the update method is used on an existing install, then
 * the app will be updated to the latest available version.  Note that it is not
 * possible to force the installation of a specific version of an app: the
 * version code is read-only.  If a user installs an app themselves (as
 * permitted by the enterprise), then again an install resource and possibly an
 * entitlement resource are automatically created.  The API can also be used to
 * delete an install resource, which triggers the removal of the app from the
 * device. Note that deleting an install does not automatically remove the
 * corresponding entitlement, even if there are no remaining installs. The
 * install resource will also be deleted if the user uninstalls the app
 * themselves.
 */
export interface Schema$Install {
    /**
     * Install state. The state "installPending" means that an install
     * request has recently been made and download to the device is in progress.
     * The state "installed" means that the app has been installed. This
     * field is read-only.
     */
    installState: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#install".
     */
    kind: string;
    /**
     * The ID of the product that the install is for. For example,
     * "app:com.google.android.gm".
     */
    productId: string;
    /**
     * The version of the installed product. Guaranteed to be set only if the
     * install state is "installed".
     */
    versionCode: number;
}
/**
 * An event generated when an app installation failed on a device
 */
export interface Schema$InstallFailureEvent {
    /**
     * The Android ID of the device. This field will always be present.
     */
    deviceId: string;
    /**
     * Additional details on the failure if applicable.
     */
    failureDetails: string;
    /**
     * The reason for the installation failure. This field will always be present.
     */
    failureReason: string;
    /**
     * The id of the product (e.g. "app:com.google.android.gm") for
     * which the install failure event occured. This field will always be present.
     */
    productId: string;
    /**
     * The ID of the user. This field will always be present.
     */
    userId: string;
}
/**
 * The install resources for the device.
 */
export interface Schema$InstallsListResponse {
    /**
     * An installation of an app for a user on a specific device. The existence of
     * an install implies that the user must have an entitlement to the app.
     */
    install: Schema$Install[];
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#installsListResponse".
     */
    kind: string;
}
/**
 * A localized string with its locale.
 */
export interface Schema$LocalizedText {
    /**
     * The BCP47 tag for a locale. (e.g. "en-US", "de").
     */
    locale: string;
    /**
     * The text localized in the associated locale.
     */
    text: string;
}
/**
 * Maintenance window for managed Google Play Accounts. This allows Play store
 * to update the apps on the foreground in the designated window.
 */
export interface Schema$MaintenanceWindow {
    /**
     * Duration of the maintenance window, in milliseconds. The duration must be
     * between 30 minutes and 24 hours (inclusive).
     */
    durationMs: string;
    /**
     * Start time of the maintenance window, in milliseconds after midnight on the
     * device. Windows can span midnight.
     */
    startTimeAfterMidnightMs: string;
}
/**
 * A managed configuration resource contains the set of managed properties
 * defined by the app developer in the app's managed configurations schema,
 * as well as any configuration variables defined for the user.
 */
export interface Schema$ManagedConfiguration {
    /**
     * Contains the ID of the managed configuration profile and the set of
     * configuration variables (if any) defined for the user.
     */
    configurationVariables: Schema$ConfigurationVariables;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#managedConfiguration".
     */
    kind: string;
    /**
     * The set of managed properties for this configuration.
     */
    managedProperty: Schema$ManagedProperty[];
    /**
     * The ID of the product that the managed configuration is for, e.g.
     * "app:com.google.android.gm".
     */
    productId: string;
}
/**
 * The managed configuration resources for the device.
 */
export interface Schema$ManagedConfigurationsForDeviceListResponse {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#managedConfigurationsForDeviceListResponse".
     */
    kind: string;
    /**
     * A managed configuration for an app on a specific device.
     */
    managedConfigurationForDevice: Schema$ManagedConfiguration[];
}
/**
 * The managed configuration resources for the user.
 */
export interface Schema$ManagedConfigurationsForUserListResponse {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#managedConfigurationsForUserListResponse".
     */
    kind: string;
    /**
     * A managed configuration for an app for a specific user.
     */
    managedConfigurationForUser: Schema$ManagedConfiguration[];
}
/**
 * A managed configurations settings resource contains the set of managed
 * properties that have been configured for an Android app to be applied to a
 * set of users. The app's developer would have defined configurable
 * properties in the managed configurations schema.
 */
export interface Schema$ManagedConfigurationsSettings {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#managedConfigurationsSettings".
     */
    kind: string;
    /**
     * The last updated time of the managed configuration settings in milliseconds
     * since 1970-01-01T00:00:00Z.
     */
    lastUpdatedTimestampMillis: string;
    /**
     * The set of managed properties for this configuration.
     */
    managedProperty: Schema$ManagedProperty[];
    /**
     * The ID of the managed configurations settings.
     */
    mcmId: string;
    /**
     * The name of the managed configurations settings.
     */
    name: string;
}
/**
 * The managed configurations settings for a product.
 */
export interface Schema$ManagedConfigurationsSettingsListResponse {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#managedConfigurationsSettingsListResponse".
     */
    kind: string;
    /**
     * A managed configurations settings for an app that may be assigned to a
     * group of users in an enterprise.
     */
    managedConfigurationsSettings: Schema$ManagedConfigurationsSettings[];
}
/**
 * A managed property of a managed configuration. The property must match one of
 * the properties in the app restrictions schema of the product. Exactly one of
 * the value fields must be populated, and it must match the property's type
 * in the app restrictions schema.
 */
export interface Schema$ManagedProperty {
    /**
     * The unique key that identifies the property.
     */
    key: string;
    /**
     * The boolean value - this will only be present if type of the property is
     * bool.
     */
    valueBool: boolean;
    /**
     * The bundle of managed properties - this will only be present if type of the
     * property is bundle.
     */
    valueBundle: Schema$ManagedPropertyBundle;
    /**
     * The list of bundles of properties - this will only be present if type of
     * the property is bundle_array.
     */
    valueBundleArray: Schema$ManagedPropertyBundle[];
    /**
     * The integer value - this will only be present if type of the property is
     * integer.
     */
    valueInteger: number;
    /**
     * The string value - this will only be present if type of the property is
     * string, choice or hidden.
     */
    valueString: string;
    /**
     * The list of string values - this will only be present if type of the
     * property is multiselect.
     */
    valueStringArray: string[];
}
/**
 * A bundle of managed properties.
 */
export interface Schema$ManagedPropertyBundle {
    /**
     * The list of managed properties.
     */
    managedProperty: Schema$ManagedProperty[];
}
/**
 * An event generated when a new device is ready to be managed.
 */
export interface Schema$NewDeviceEvent {
    /**
     * The Android ID of the device. This field will always be present.
     */
    deviceId: string;
    /**
     * Policy app on the device.
     */
    dpcPackageName: string;
    /**
     * Identifies the extent to which the device is controlled by an Android EMM
     * in various deployment configurations.  Possible values include:  -
     * "managedDevice", a device where the DPC is set as device owner,
     * - "managedProfile", a device where the DPC is set as profile
     * owner.
     */
    managementType: string;
    /**
     * The ID of the user. This field will always be present.
     */
    userId: string;
}
/**
 * An event generated when new permissions are added to an app.
 */
export interface Schema$NewPermissionsEvent {
    /**
     * The set of permissions that the enterprise admin has already approved for
     * this application. Use Permissions.Get on the EMM API to retrieve details
     * about these permissions.
     */
    approvedPermissions: string[];
    /**
     * The id of the product (e.g. "app:com.google.android.gm") for
     * which new permissions were added. This field will always be present.
     */
    productId: string;
    /**
     * The set of permissions that the app is currently requesting. Use
     * Permissions.Get on the EMM API to retrieve details about these permissions.
     */
    requestedPermissions: string[];
}
/**
 * A notification of one event relating to an enterprise.
 */
export interface Schema$Notification {
    /**
     * Notifications about new app restrictions schema changes.
     */
    appRestrictionsSchemaChangeEvent: Schema$AppRestrictionsSchemaChangeEvent;
    /**
     * Notifications about app updates.
     */
    appUpdateEvent: Schema$AppUpdateEvent;
    /**
     * The ID of the enterprise for which the notification is sent. This will
     * always be present.
     */
    enterpriseId: string;
    /**
     * Notifications about an app installation failure.
     */
    installFailureEvent: Schema$InstallFailureEvent;
    /**
     * Notifications about new devices.
     */
    newDeviceEvent: Schema$NewDeviceEvent;
    /**
     * Notifications about new app permissions.
     */
    newPermissionsEvent: Schema$NewPermissionsEvent;
    /**
     * Type of the notification.
     */
    notificationType: string;
    /**
     * Notifications about changes to a product's approval status.
     */
    productApprovalEvent: Schema$ProductApprovalEvent;
    /**
     * Notifications about product availability changes.
     */
    productAvailabilityChangeEvent: Schema$ProductAvailabilityChangeEvent;
    /**
     * The time when the notification was published in milliseconds since
     * 1970-01-01T00:00:00Z. This will always be present.
     */
    timestampMillis: string;
}
/**
 * A resource returned by the PullNotificationSet API, which contains a
 * collection of notifications for enterprises associated with the service
 * account authenticated for the request.
 */
export interface Schema$NotificationSet {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#notificationSet".
     */
    kind: string;
    /**
     * The notifications received, or empty if no notifications are present.
     */
    notification: Schema$Notification[];
    /**
     * The notification set ID, required to mark the notification as received with
     * the Enterprises.AcknowledgeNotification API. This will be omitted if no
     * notifications are present.
     */
    notificationSetId: string;
}
export interface Schema$PageInfo {
    resultPerPage: number;
    startIndex: number;
    totalResults: number;
}
/**
 * A Permissions resource represents some extra capability, to be granted to an
 * Android app, which requires explicit consent. An enterprise admin must
 * consent to these permissions on behalf of their users before an entitlement
 * for the app can be created.  The permissions collection is read-only. The
 * information provided for each permission (localized name and description) is
 * intended to be used in the MDM user interface when obtaining consent from the
 * enterprise.
 */
export interface Schema$Permission {
    /**
     * A longer description of the Permissions resource, giving more details of
     * what it affects.
     */
    description: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#permission".
     */
    kind: string;
    /**
     * The name of the permission.
     */
    name: string;
    /**
     * An opaque string uniquely identifying the permission.
     */
    permissionId: string;
}
/**
 * The device policy for a given managed device.
 */
export interface Schema$Policy {
    /**
     * The auto-update policy for apps installed on the device.
     * "choiceToTheUser" allows the device's user to configure the
     * app update policy. "always" enables auto updates.
     * "never" disables auto updates. "wifiOnly" enables auto
     * updates only when the device is connected to wifi.
     */
    autoUpdatePolicy: string;
    /**
     * The maintenance window defining when apps running in the foreground should
     * be updated. This feature is only supported on fully managed devices.
     */
    maintenanceWindow: Schema$MaintenanceWindow;
    /**
     * The availability granted to the device for the specified products.
     * "all" gives the device access to all products, regardless of
     * approval status. "allApproved" entitles the device to access all
     * products that are approved for the enterprise. "allApproved" and
     * "all" do not enable automatic visibility of "alpha" or
     * "beta" tracks. "whitelist" grants the device access the
     * products specified in productPolicy[]. Only products that are approved or
     * products that were previously approved (products with revoked approval) by
     * the enterprise can be whitelisted. If no value is provided, the
     * availability set at the user level is applied by default.
     */
    productAvailabilityPolicy: string;
    /**
     * The list of product policies.
     */
    productPolicy: Schema$ProductPolicy[];
}
/**
 * A Products resource represents an app in the Google Play store that is
 * available to at least some users in the enterprise. (Some apps are restricted
 * to a single enterprise, and no information about them is made available
 * outside that enterprise.)  The information provided for each product
 * (localized name, icon, link to the full Google Play details page) is intended
 * to allow a basic representation of the product within an EMM user interface.
 */
export interface Schema$Product {
    /**
     * App versions currently available for this product.
     */
    appVersion: Schema$AppVersion[];
    /**
     * The name of the author of the product (for example, the app developer).
     */
    authorName: string;
    /**
     * The countries which this app is available in.
     */
    availableCountries: string[];
    /**
     * The tracks that are visible to the enterprise.
     */
    availableTracks: string[];
    /**
     * The app category (e.g. RACING, SOCIAL, etc.)
     */
    category: string;
    /**
     * The content rating for this app.
     */
    contentRating: string;
    /**
     * The localized promotional description, if available.
     */
    description: string;
    /**
     * A link to the (consumer) Google Play details page for the product.
     */
    detailsUrl: string;
    /**
     * How and to whom the package is made available. The value publicGoogleHosted
     * means that the package is available through the Play store and not
     * restricted to a specific enterprise. The value privateGoogleHosted means
     * that the package is a private app (restricted to an enterprise) but hosted
     * by Google. The value privateSelfHosted means that the package is a private
     * app (restricted to an enterprise) and is privately hosted.
     */
    distributionChannel: string;
    /**
     * A link to an image that can be used as an icon for the product. This image
     * is suitable for use at up to 512px x 512px.
     */
    iconUrl: string;
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#product".
     */
    kind: string;
    /**
     * The approximate time (within 7 days) the app was last published, expressed
     * in milliseconds since epoch.
     */
    lastUpdatedTimestampMillis: string;
    /**
     * The minimum Android SDK necessary to run the app.
     */
    minAndroidSdkVersion: number;
    /**
     * A list of permissions required by the app.
     */
    permissions: Schema$ProductPermission[];
    /**
     * A string of the form app:<package name>. For example,
     * app:com.google.android.gm represents the Gmail app.
     */
    productId: string;
    /**
     * Whether this product is free, free with in-app purchases, or paid. If the
     * pricing is unknown, this means the product is not generally available
     * anymore (even though it might still be available to people who own it).
     */
    productPricing: string;
    /**
     * A description of the recent changes made to the app.
     */
    recentChanges: string;
    /**
     * Deprecated.
     */
    requiresContainerApp: boolean;
    /**
     * A list of screenshot links representing the app.
     */
    screenshotUrls: string[];
    /**
     * The certificate used to sign this product.
     */
    signingCertificate: Schema$ProductSigningCertificate;
    /**
     * A link to a smaller image that can be used as an icon for the product. This
     * image is suitable for use at up to 128px x 128px.
     */
    smallIconUrl: string;
    /**
     * The name of the product.
     */
    title: string;
    /**
     * A link to the managed Google Play details page for the product, for use by
     * an Enterprise admin.
     */
    workDetailsUrl: string;
}
/**
 * An event generated when a product's approval status is changed.
 */
export interface Schema$ProductApprovalEvent {
    /**
     * Whether the product was approved or unapproved. This field will always be
     * present.
     */
    approved: string;
    /**
     * The id of the product (e.g. "app:com.google.android.gm") for
     * which the approval status has changed. This field will always be present.
     */
    productId: string;
}
/**
 * An event generated whenever a product's availability changes.
 */
export interface Schema$ProductAvailabilityChangeEvent {
    /**
     * The new state of the product. This field will always be present.
     */
    availabilityStatus: string;
    /**
     * The id of the product (e.g. "app:com.google.android.gm") for
     * which the product availability changed. This field will always be present.
     */
    productId: string;
}
/**
 * A product permissions resource represents the set of permissions required by
 * a specific app and whether or not they have been accepted by an enterprise
 * admin.  The API can be used to read the set of permissions, and also to
 * update the set to indicate that permissions have been accepted.
 */
export interface Schema$ProductPermission {
    /**
     * An opaque string uniquely identifying the permission.
     */
    permissionId: string;
    /**
     * Whether the permission has been accepted or not.
     */
    state: string;
}
/**
 * Information about the permissions required by a specific app and whether they
 * have been accepted by the enterprise.
 */
export interface Schema$ProductPermissions {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#productPermissions".
     */
    kind: string;
    /**
     * The permissions required by the app.
     */
    permission: Schema$ProductPermission[];
    /**
     * The ID of the app that the permissions relate to, e.g.
     * "app:com.google.android.gm".
     */
    productId: string;
}
/**
 * The policy for a product.
 */
export interface Schema$ProductPolicy {
    /**
     * The ID of the product. For example, "app:com.google.android.gm".
     */
    productId: string;
    /**
     * Grants visibility to the specified track(s) of the product to the device.
     * The track available to the device is based on the following order of
     * preference: alpha, beta, production. For example, if an app has a prod
     * version, a beta version and an alpha version and the enterprise has been
     * granted visibility to both the alpha and beta tracks, if tracks is
     * {"beta", "production"} then the beta version of the app
     * is made available to the device. If there are no app versions in the
     * specified track adding the "alpha" and "beta" values to
     * the list of tracks will have no effect. Note that the enterprise requires
     * access to alpha and/or beta tracks before users can be granted visibility
     * to apps in those tracks.  The allowed sets are: {} (considered equivalent
     * to {"production"}) {"production"} {"beta",
     * "production"} {"alpha", "beta",
     * "production"} The order of elements is not relevant. Any other
     * set of tracks will be rejected with an error.
     */
    tracks: string[];
}
export interface Schema$ProductsApproveRequest {
    /**
     * The approval URL that was shown to the user. Only the permissions shown to
     * the user with that URL will be accepted, which may not be the product's
     * entire set of permissions. For example, the URL may only display new
     * permissions from an update after the product was approved, or not include
     * new permissions if the product was updated since the URL was generated.
     */
    approvalUrlInfo: Schema$ApprovalUrlInfo;
    /**
     * Sets how new permission requests for the product are handled.
     * "allPermissions" automatically approves all current and future
     * permissions for the product. "currentPermissionsOnly" approves
     * the current set of permissions for the product, but any future permissions
     * added through updates will require manual reapproval. If not specified,
     * only the current set of permissions will be approved.
     */
    approvedPermissions: string;
}
/**
 * A set of products.
 */
export interface Schema$ProductSet {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#productSet".
     */
    kind: string;
    /**
     * The list of product IDs making up the set of products.
     */
    productId: string[];
    /**
     * The interpretation of this product set. "unknown" should never be
     * sent and is ignored if received. "whitelist" means that the user
     * is entitled to access the product set. "includeAll" means that
     * all products are accessible, including products that are approved, products
     * with revoked approval, and products that have never been approved.
     * "allApproved" means that the user is entitled to access all
     * products that are approved for the enterprise. If the value is
     * "allApproved" or "includeAll", the productId field is
     * ignored. If no value is provided, it is interpreted as
     * "whitelist" for backwards compatibility. Further
     * "allApproved" or "includeAll" does not enable automatic
     * visibility of "alpha" or "beta" tracks for Android app.
     * Use ProductVisibility to enable "alpha" or "beta"
     * tracks per user.
     */
    productSetBehavior: string;
    /**
     * Additional list of product IDs making up the product set. Unlike the
     * productID array, in this list It's possible to specify which tracks
     * (alpha, beta, production) of a product are visible to the user. See
     * ProductVisibility and its fields for more information. Specifying the same
     * product ID both here and in the productId array is not allowed and it will
     * result in an error.
     */
    productVisibility: Schema$ProductVisibility[];
}
export interface Schema$ProductsGenerateApprovalUrlResponse {
    /**
     * A URL that can be rendered in an iframe to display the permissions (if any)
     * of a product. This URL can be used to approve the product only once and
     * only within 24 hours of being generated, using the Products.approve call.
     * If the product is currently unapproved and has no permissions, this URL
     * will point to an empty page. If the product is currently approved, a URL
     * will only be generated if that product has added permissions since it was
     * last approved, and the URL will only display those new permissions that
     * have not yet been accepted.
     */
    url: string;
}
export interface Schema$ProductSigningCertificate {
    /**
     * The base64 urlsafe encoded SHA1 hash of the certificate. (This field is
     * deprecated in favor of SHA2-256. It should not be used and may be removed
     * at any time.)
     */
    certificateHashSha1: string;
    /**
     * The base64 urlsafe encoded SHA2-256 hash of the certificate.
     */
    certificateHashSha256: string;
}
/**
 * The matching products.
 */
export interface Schema$ProductsListResponse {
    /**
     * Identifies what kind of resource this is. Value: the fixed string
     * "androidenterprise#productsListResponse".
     */
    kind: string;
    /**
     * General pagination information.
     */
    pageInfo: Schema$PageInfo;
    /**
     * Information about a product (e.g. an app) in the Google Play store, for
     * display to an enterprise admin.
     */
    product: Schema$Product[];
    /**
     * Pagination information for token pagination.
     */
    tokenPagination: Schema$TokenPagination;
}
/**
 * A product to be made visible to a user.
 */
export interface Schema$ProductVisibility {
    /**
     * The product ID to make visible to the user. Required for each item in the
     * productVisibility list.
     */
    productId: string;
    /**
     * Grants visibility to the specified track(s) of the product to the user. The
     * track available to the user is based on the following order