googleapis/build/src/apis/androiddeviceprovisioning/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 Device Provisioning Partner API
 *
 * Automates Android zero-touch enrollment for device resellers, customers, and
 * EMMs.
 *
 * @example
 * const google = require('googleapis');
 * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
 *
 * @namespace androiddeviceprovisioning
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for Androiddeviceprovisioning
 */
export declare class Androiddeviceprovisioning {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    customers: Resource$Customers;
    operations: Resource$Operations;
    partners: Resource$Partners;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * Request message to claim a device on behalf of a customer.
 */
export interface Schema$ClaimDeviceRequest {
    /**
     * Required. The ID of the customer for whom the device is being claimed.
     */
    customerId: string;
    /**
     * Required. The device identifier of the device to claim.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The section type of the device's provisioning record.
     */
    sectionType: string;
}
/**
 * Response message containing device id of the claim.
 */
export interface Schema$ClaimDeviceResponse {
    /**
     * The device ID of the claimed device.
     */
    deviceId: string;
    /**
     * The resource name of the device in the format
     * `partners/[PARTNER_ID]/devices/[DEVICE_ID]`.
     */
    deviceName: string;
}
/**
 * Request to claim devices asynchronously in batch. Claiming a device adds the
 * device to zero-touch enrollment and shows the device in the customer's
 * view of the portal.
 */
export interface Schema$ClaimDevicesRequest {
    /**
     * Required. A list of device claims.
     */
    claims: Schema$PartnerClaim[];
}
/**
 * A customer resource in the zero-touch enrollment API.
 */
export interface Schema$Company {
    /**
     * Input only. Optional. Email address of customer's users in the admin
     * role. Each email address must be associated with a Google Account.
     */
    adminEmails: string[];
    /**
     * Output only. The ID of the company. Assigned by the server.
     */
    companyId: string;
    /**
     * Required. The name of the company. For example _XYZ Corp_. Characters
     * allowed are: Latin letters, numerals, hyphens, and spaces. Displayed to the
     * customer's employees in the zero-touch enrollment portal.
     */
    companyName: string;
    /**
     * Output only. The API resource name of the company in the format
     * `partners/[PARTNER_ID]/customers/[CUSTOMER_ID]`. Assigned by the server.
     */
    name: string;
    /**
     * Input only. Email address of customer's users in the owner role. At
     * least one `owner_email` is required. Each email address must be associated
     * with a Google Account. Owners share the same access as admins but can also
     * add, delete, and edit your organization's portal users.
     */
    ownerEmails: string[];
}
/**
 * A configuration collects the provisioning options for Android devices. Each
 * configuration combines the following:  * The EMM device policy controller
 * (DPC) installed on the devices. * EMM policies enforced on the devices. *
 * Metadata displayed on the device to help users during setup.  Customers can
 * add as many configurations as they need. However, zero-touch enrollment works
 * best when a customer sets a default configuration that's applied to any
 * new devices the organization purchases.
 */
export interface Schema$Configuration {
    /**
     * Required. The name of the organization. Zero-touch enrollment shows this
     * organization name to device users during device provisioning.
     */
    companyName: string;
    /**
     * Output only. The ID of the configuration. Assigned by the server.
     */
    configurationId: string;
    /**
     * Required. A short name that describes the configuration's purpose. For
     * example, _Sales team_ or _Temporary employees_. The zero-touch enrollment
     * portal displays this name to IT admins.
     */
    configurationName: string;
    /**
     * Required. The email address that device users can contact to get help.
     * Zero-touch enrollment shows this email address to device users before
     * device provisioning. The value is validated on input.
     */
    contactEmail: string;
    /**
     * Required. The telephone number that device users can call, using another
     * device, to get help. Zero-touch enrollment shows this number to device
     * users before device provisioning. Accepts numerals, spaces, the plus sign,
     * hyphens, and parentheses.
     */
    contactPhone: string;
    /**
     * A message, containing one or two sentences, to help device users get help
     * or give them more details about what’s happening to their device.
     * Zero-touch enrollment shows this message before the device is provisioned.
     */
    customMessage: string;
    /**
     * The JSON-formatted EMM provisioning extras that are passed to the DPC.
     */
    dpcExtras: string;
    /**
     * Required. The resource name of the selected DPC (device policy controller)
     * in the format `customers/[CUSTOMER_ID]/dpcs/x. To list the supported DPCs,
     * call `customers.dpcs.list`.
     */
    dpcResourcePath: string;
    /**
     * Required. Whether this is the default configuration that zero-touch
     * enrollment applies to any new devices the organization purchases in the
     * future. Only one customer configuration can be the default. Setting this
     * value to `true`, changes the previous default configuration's
     * `isDefault` value to `false`.
     */
    isDefault: boolean;
    /**
     * Output only. The API resource name in the format
     * `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. Assigned by
     * the server.
     */
    name: string;
}
/**
 * Request message to create a customer.
 */
export interface Schema$CreateCustomerRequest {
    /**
     * Required. The company data to populate the new customer. Must contain a
     * value for `companyName` and at least one `owner_email` that's
     * associated with a Google Account. The values for `companyId` and `name`
     * must be empty.
     */
    customer: Schema$Company;
}
/**
 * Request message for customer to assign a configuration to device.
 */
export interface Schema$CustomerApplyConfigurationRequest {
    /**
     * Required. The configuration applied to the device in the format
     * `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`.
     */
    configuration: string;
    /**
     * Required. The device the configuration is applied to.
     */
    device: Schema$DeviceReference;
}
/**
 * Response message of customer's listing configuration.
 */
export interface Schema$CustomerListConfigurationsResponse {
    /**
     * The configurations.
     */
    configurations: Schema$Configuration[];
}
/**
 * Response message for listing my customers.
 */
export interface Schema$CustomerListCustomersResponse {
    /**
     * The customer accounts the calling user is a member of.
     */
    customers: Schema$Company[];
    /**
     * A token used to access the next page of results. Omitted if no further
     * results are available.
     */
    nextPageToken: string;
}
/**
 * Response message of customer's liting devices.
 */
export interface Schema$CustomerListDevicesResponse {
    /**
     * The customer's devices.
     */
    devices: Schema$Device[];
    /**
     * A token used to access the next page of results. Omitted if no further
     * results are available.
     */
    nextPageToken: string;
}
/**
 * Response message of customer's listing DPCs.
 */
export interface Schema$CustomerListDpcsResponse {
    /**
     * The list of DPCs available to the customer that support zero-touch
     * enrollment.
     */
    dpcs: Schema$Dpc[];
}
/**
 * Request message for customer to remove the configuration from device.
 */
export interface Schema$CustomerRemoveConfigurationRequest {
    /**
     * Required. The device to remove the configuration from.
     */
    device: Schema$DeviceReference;
}
/**
 * Request message for customer to unclaim a device.
 */
export interface Schema$CustomerUnclaimDeviceRequest {
    /**
     * Required. The device to unclaim.
     */
    device: Schema$DeviceReference;
}
/**
 * An Android device registered for zero-touch enrollment.
 */
export interface Schema$Device {
    /**
     * Output only. The provisioning claims for a device. Devices claimed for
     * zero-touch enrollment have a claim with the type `SECTION_TYPE_ZERO_TOUCH`.
     * Call `partners.devices.unclaim` or `partners.devices.unclaimAsync` to
     * remove the device from zero-touch enrollment.
     */
    claims: Schema$DeviceClaim[];
    /**
     * Not available to resellers.
     */
    configuration: string;
    /**
     * Output only. The ID of the device. Assigned by the server.
     */
    deviceId: string;
    /**
     * The hardware IDs that identify a manufactured device. To learn more, read
     * [Identifiers](/zero-touch/guides/identifiers).
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * The metadata attached to the device. Structured as key-value pairs. To
     * learn more, read [Device metadata](/zero-touch/guides/metadata).
     */
    deviceMetadata: Schema$DeviceMetadata;
    /**
     * Output only. The API resource name in the format
     * `partners/[PARTNER_ID]/devices/[DEVICE_ID]`. Assigned by the server.
     */
    name: string;
}
/**
 * A record of a device claimed by a reseller for a customer. Devices claimed
 * for zero-touch enrollment have a claim with the type
 * `SECTION_TYPE_ZERO_TOUCH`. To learn more, read [Claim devices for
 * customers](/zero-touch/guides/how-it-works#claim).
 */
export interface Schema$DeviceClaim {
    /**
     * The ID of the Customer that purchased the device.
     */
    ownerCompanyId: string;
    /**
     * Output only. The type of claim made on the device.
     */
    sectionType: string;
}
/**
 * Encapsulates hardware and product IDs to identify a manufactured device. To
 * learn more, read [Identifiers](/zero-touch/guides/identifiers).
 */
export interface Schema$DeviceIdentifier {
    /**
     * The device’s IMEI number. Validated on input.
     */
    imei: string;
    /**
     * Required. The device manufacturer’s name. Matches the device's built-in
     * value returned from `android.os.Build.MANUFACTURER`. Allowed values are
     * listed in [manufacturer names](/zero-touch/resources/manufacturer-names).
     */
    manufacturer: string;
    /**
     * The device’s MEID number.
     */
    meid: string;
    /**
     * The manufacturer's serial number for the device. This value might not
     * be unique.
     */
    serialNumber: string;
}
/**
 * Metadata entries that can be attached to a `Device`. To learn more, read
 * [Device metadata](/zero-touch/guides/metadata).
 */
export interface Schema$DeviceMetadata {
    /**
     * Metadata entries recorded as key-value pairs.
     */
    entries: any;
}
/**
 * A `DeviceReference` is an API abstraction that lets you supply a _device_
 * argument to a method using one of the following identifier types:  * A
 * numeric API resource ID. * Real-world hardware IDs, such as IMEI number,
 * belonging to the manufactured   device.  Methods that operate on devices take
 * a `DeviceReference` as a parameter type because it's more flexible for
 * the caller. To learn more about device identifiers, read
 * [Identifiers](/zero-touch/guides/identifiers).
 */
export interface Schema$DeviceReference {
    /**
     * The ID of the device.
     */
    deviceId: string;
    /**
     * The hardware IDs of the device.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
}
/**
 * Tracks the status of a long-running operation to asynchronously update a
 * batch of reseller metadata attached to devices. To learn more, read
 * [Long‑running batch operations](/zero-touch/guides/how-it-works#operations).
 */
export interface Schema$DevicesLongRunningOperationMetadata {
    /**
     * The number of metadata updates in the operation. This might be different
     * from the number of updates in the request if the API can't parse some
     * of the updates.
     */
    devicesCount: number;
    /**
     * The processing status of the operation.
     */
    processingStatus: string;
    /**
     * The processing progress of the operation. Measured as a number from 0 to
     * 100. A value of 10O doesnt always mean the operation completed—check for
     * the inclusion of a `done` field.
     */
    progress: number;
}
/**
 * Tracks the status of a long-running operation to claim, unclaim, or attach
 * metadata to devices. To learn more, read [Long‑running batch
 * operations](/zero-touch/guides/how-it-works#operations).
 */
export interface Schema$DevicesLongRunningOperationResponse {
    /**
     * The processing status for each device in the operation. One
     * `PerDeviceStatus` per device. The list order matches the items in the
     * original request.
     */
    perDeviceStatus: Schema$OperationPerDevice[];
    /**
     * A summary of how many items in the operation the server processed
     * successfully. Updated as the operation progresses.
     */
    successCount: number;
}
/**
 * An EMM's DPC ([device policy controller](/android/work/dpc/build-dpc)).
 * Zero-touch enrollment installs a DPC (listed in the `Configuration`) on a
 * device to maintain the customer's mobile policies. All the DPCs listed by
 * the API support zero-touch enrollment and are available in Google Play.
 */
export interface Schema$Dpc {
    /**
     * Output only. The title of the DPC app in Google Play. For example, _Google
     * Apps Device Policy_. Useful in an application's user interface.
     */
    dpcName: string;
    /**
     * Output only. The API resource name in the format
     * `customers/[CUSTOMER_ID]/dpcs/[DPC_ID]`. Assigned by the server. To
     * maintain a reference to a DPC across customer accounts, persist and match
     * the last path component (`DPC_ID`).
     */
    name: string;
    /**
     * Output only. The DPC's Android application ID that looks like a Java
     * package name. Zero-touch enrollment installs the DPC app onto a device
     * using this identifier.
     */
    packageName: string;
}
/**
 * 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 {
}
/**
 * Request to find devices.
 */
export interface Schema$FindDevicesByDeviceIdentifierRequest {
    /**
     * Required. The device identifier to search for.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The maximum number of devices to show in a page of results. Must
     * be between 1 and 100 inclusive.
     */
    limit: string;
    /**
     * A token specifying which result page to return.
     */
    pageToken: string;
}
/**
 * Response containing found devices.
 */
export interface Schema$FindDevicesByDeviceIdentifierResponse {
    /**
     * Found devices.
     */
    devices: Schema$Device[];
    /**
     * A token used to access the next page of results. Omitted if no further
     * results are available.
     */
    nextPageToken: string;
}
/**
 * Request to find devices by customers.
 */
export interface Schema$FindDevicesByOwnerRequest {
    /**
     * Required. The list of customer IDs to search for.
     */
    customerId: string[];
    /**
     * Required. The maximum number of devices to show in a page of results. Must
     * be between 1 and 100 inclusive.
     */
    limit: string;
    /**
     * A token specifying which result page to return.
     */
    pageToken: string;
    /**
     * Required. The section type of the device's provisioning record.
     */
    sectionType: string;
}
/**
 * Response containing found devices.
 */
export interface Schema$FindDevicesByOwnerResponse {
    /**
     * The customer's devices.
     */
    devices: Schema$Device[];
    /**
     * A token used to access the next page of results. Omitted if no further
     * results are available.
     */
    nextPageToken: string;
}
/**
 * Response message of all customers related to this partner.
 */
export interface Schema$ListCustomersResponse {
    /**
     * List of customers related to this reseller partner.
     */
    customers: Schema$Company[];
}
/**
 * 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;
    /**
     * This field will always be not set if the operation is created by
     * `claimAsync`, `unclaimAsync`, or `updateMetadataAsync`. In this case, error
     * information for each device is set in
     * `response.perDeviceStatus.result.status`.
     */
    error: Schema$Status;
    /**
     * This field will contain a `DevicesLongRunningOperationMetadata` object if
     * the operation is created by `claimAsync`, `unclaimAsync`, or
     * `updateMetadataAsync`.
     */
    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;
    /**
     * This field will contain a `DevicesLongRunningOperationResponse` object if
     * the operation is created by `claimAsync`, `unclaimAsync`, or
     * `updateMetadataAsync`.
     */
    response: any;
}
/**
 * A task for each device in the operation. Corresponds to each device change in
 * the request.
 */
export interface Schema$OperationPerDevice {
    /**
     * A copy of the original device-claim request received by the server.
     */
    claim: Schema$PartnerClaim;
    /**
     * The processing result for each device.
     */
    result: Schema$PerDeviceStatusInBatch;
    /**
     * A copy of the original device-unclaim request received by the server.
     */
    unclaim: Schema$PartnerUnclaim;
    /**
     * A copy of the original metadata-update request received by the server.
     */
    updateMetadata: Schema$UpdateMetadataArguments;
}
/**
 * Identifies one claim request.
 */
export interface Schema$PartnerClaim {
    /**
     * Required. The ID of the customer for whom the device is being claimed.
     */
    customerId: string;
    /**
     * Required. Device identifier of the device.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The metadata to attach to the device at claim.
     */
    deviceMetadata: Schema$DeviceMetadata;
    /**
     * Required. The section type of the device's provisioning record.
     */
    sectionType: string;
}
/**
 * Identifies one unclaim request.
 */
export interface Schema$PartnerUnclaim {
    /**
     * Device ID of the device.
     */
    deviceId: string;
    /**
     * Device identifier of the device.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The section type of the device's provisioning record.
     */
    sectionType: string;
}
/**
 * Captures the processing status for each device in the operation.
 */
export interface Schema$PerDeviceStatusInBatch {
    /**
     * If processing succeeds, the device ID of the device.
     */
    deviceId: string;
    /**
     * If processing fails, the error type.
     */
    errorIdentifier: string;
    /**
     * If processing fails, a developer message explaining what went wrong.
     */
    errorMessage: string;
    /**
     * The result status of the device after processing.
     */
    status: 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 needs  # Overview  The `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 mapping  The `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 uses  The 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
 * environments.  Example uses of this error model include:  - Partial errors.
 * If a service needs to return partial errors to the client,     it may embed
 * the `Status` in the normal response to indicate the partial     errors.  -
 * Workflow errors. A typical workflow has multiple steps. Each step may have a
 * `Status` message for error reporting.  - Batch operations. If a client uses
 * batch request and batch response, the     `Status` message should be used
 * directly inside batch response, one for     each error sub-response.  -
 * Asynchronous operations. If an API call embeds asynchronous operation results
 * in its response, the status of those operations should be     represented
 * directly using the `Status` message.  - Logging. If some API errors are
 * stored in logs, the message `Status` could     be used directly after any
 * stripping needed for security/privacy reasons.
 */
export interface Schema$Status {
    /**
     * The status code, which should be an enum value of google.rpc.Code.
     */
    code: number;
    /**
     * A list of messages that carry the error details.  There is a common set of
     * message types for APIs to use.
     */
    details: any[];
    /**
     * A developer-facing error message, which should be in English. Any
     * user-facing error message should be localized and sent in the
     * google.rpc.Status.details field, or localized by the client.
     */
    message: string;
}
/**
 * Request message to unclaim a device.
 */
export interface Schema$UnclaimDeviceRequest {
    /**
     * The device ID returned by `ClaimDevice`.
     */
    deviceId: string;
    /**
     * The device identifier you used when you claimed this device.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The section type of the device's provisioning record.
     */
    sectionType: string;
}
/**
 * Request to unclaim devices asynchronously in batch.
 */
export interface Schema$UnclaimDevicesRequest {
    /**
     * Required. The list of devices to unclaim.
     */
    unclaims: Schema$PartnerUnclaim[];
}
/**
 * Request to update device metadata in batch.
 */
export interface Schema$UpdateDeviceMetadataInBatchRequest {
    /**
     * Required. The list of metadata updates.
     */
    updates: Schema$UpdateMetadataArguments[];
}
/**
 * Request to set metadata for a device.
 */
export interface Schema$UpdateDeviceMetadataRequest {
    /**
     * Required. The metdata to attach to the device.
     */
    deviceMetadata: Schema$DeviceMetadata;
}
/**
 * Identifies metdata updates to one device.
 */
export interface Schema$UpdateMetadataArguments {
    /**
     * Device ID of the device.
     */
    deviceId: string;
    /**
     * Device identifier.
     */
    deviceIdentifier: Schema$DeviceIdentifier;
    /**
     * Required. The metadata to update.
     */
    deviceMetadata: Schema$DeviceMetadata;
}
export declare class Resource$Customers {
    root: Androiddeviceprovisioning;
    configurations: Resource$Customers$Configurations;
    devices: Resource$Customers$Devices;
    dpcs: Resource$Customers$Dpcs;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.customers.list
     * @desc Lists the user's customer accounts.
     * @alias androiddeviceprovisioning.customers.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {integer=} params.pageSize The maximum number of customers to show in a page of results. A number between 1 and 100 (inclusive).
     * @param {string=} params.pageToken A token specifying which result page to return.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$CustomerListCustomersResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CustomerListCustomersResponse>, callback?: BodyResponseCallback<Schema$CustomerListCustomersResponse>): void;
}
export declare class Resource$Customers$Configurations {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.customers.configurations.create
     * @desc Creates a new configuration. Once created, a customer can apply the
     * configuration to devices.
     * @alias androiddeviceprovisioning.customers.configurations.create
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer that manages the configuration. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {().Configuration} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    create(params?: any, options?: MethodOptions): AxiosPromise<Schema$Configuration>;
    create(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Configuration>, callback?: BodyResponseCallback<Schema$Configuration>): void;
    /**
     * androiddeviceprovisioning.customers.configurations.delete
     * @desc Deletes an unused configuration. The API call fails if the customer
     * has devices with the configuration applied.
     * @alias androiddeviceprovisioning.customers.configurations.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name Required. The configuration to delete. An API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. If the configuration is applied to any devices, the API call fails.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    delete(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    delete(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * androiddeviceprovisioning.customers.configurations.get
     * @desc Gets the details of a configuration.
     * @alias androiddeviceprovisioning.customers.configurations.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name Required. The configuration to get. An API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Configuration>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Configuration>, callback?: BodyResponseCallback<Schema$Configuration>): void;
    /**
     * androiddeviceprovisioning.customers.configurations.list
     * @desc Lists a customer's configurations.
     * @alias androiddeviceprovisioning.customers.configurations.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer that manages the listed configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$CustomerListConfigurationsResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CustomerListConfigurationsResponse>, callback?: BodyResponseCallback<Schema$CustomerListConfigurationsResponse>): void;
    /**
     * androiddeviceprovisioning.customers.configurations.patch
     * @desc Updates a configuration's field values.
     * @alias androiddeviceprovisioning.customers.configurations.patch
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name Output only. The API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. Assigned by the server.
     * @param {string=} params.updateMask Required. The field mask applied to the target `Configuration` before updating the fields. To learn more about using field masks, read [FieldMask](/protocol-buffers/docs/reference/google.protobuf#fieldmask) in the Protocol Buffers documentation.
     * @param {().Configuration} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    patch(params?: any, options?: MethodOptions): AxiosPromise<Schema$Configuration>;
    patch(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Configuration>, callback?: BodyResponseCallback<Schema$Configuration>): void;
}
export declare class Resource$Customers$Devices {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.customers.devices.applyConfiguration
     * @desc Applies a Configuration to the device to register the device for
     * zero-touch enrollment. After applying a configuration to a device, the
     * device automatically provisions itself on first boot, or next factory
     * reset.
     * @alias androiddeviceprovisioning.customers.devices.applyConfiguration
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {().CustomerApplyConfigurationRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    applyConfiguration(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    applyConfiguration(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * androiddeviceprovisioning.customers.devices.get
     * @desc Gets the details of a device.
     * @alias androiddeviceprovisioning.customers.devices.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name Required. The device to get. An API resource name in the format `customers/[CUSTOMER_ID]/devices/[DEVICE_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Device>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Device>, callback?: BodyResponseCallback<Schema$Device>): void;
    /**
     * androiddeviceprovisioning.customers.devices.list
     * @desc Lists a customer's devices.
     * @alias androiddeviceprovisioning.customers.devices.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string=} params.pageSize The maximum number of devices to show in a page of results. Must be between 1 and 100 inclusive.
     * @param {string=} params.pageToken A token specifying which result page to return.
     * @param {string} params.parent Required. The customer managing the devices. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$CustomerListDevicesResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CustomerListDevicesResponse>, callback?: BodyResponseCallback<Schema$CustomerListDevicesResponse>): void;
    /**
     * androiddeviceprovisioning.customers.devices.removeConfiguration
     * @desc Removes a configuration from device.
     * @alias androiddeviceprovisioning.customers.devices.removeConfiguration
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer managing the device in the format `customers/[CUSTOMER_ID]`.
     * @param {().CustomerRemoveConfigurationRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    removeConfiguration(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    removeConfiguration(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * androiddeviceprovisioning.customers.devices.unclaim
     * @desc Unclaims a device from a customer and removes it from zero-touch
     * enrollment.  After removing a device, a customer must contact their
     * reseller to register the device into zero-touch enrollment again.
     * @alias androiddeviceprovisioning.customers.devices.unclaim
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {().CustomerUnclaimDeviceRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    unclaim(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    unclaim(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
}
export declare class Resource$Customers$Dpcs {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.customers.dpcs.list
     * @desc Lists the DPCs (device policy controllers) that support zero-touch
     * enrollment.
     * @alias androiddeviceprovisioning.customers.dpcs.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The customer that can use the DPCs in configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$CustomerListDpcsResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$CustomerListDpcsResponse>, callback?: BodyResponseCallback<Schema$CustomerListDpcsResponse>): void;
}
export declare class Resource$Operations {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.operations.get
     * @desc Gets the latest state of a long-running operation.  Clients can use
     * this method to poll the operation result at intervals as recommended by the
     * API service.
     * @alias androiddeviceprovisioning.operations.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name The name of the operation resource.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Operation>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Operation>, callback?: BodyResponseCallback<Schema$Operation>): void;
}
export declare class Resource$Partners {
    root: Androiddeviceprovisioning;
    customers: Resource$Partners$Customers;
    devices: Resource$Partners$Devices;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
}
export declare class Resource$Partners$Customers {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.partners.customers.create
     * @desc Creates a customer for zero-touch enrollment. After the method
     * returns successfully, admin and owner roles can manage devices and EMM
     * configs by calling API methods or using their zero-touch enrollment portal.
     * The API doesn't notify the customer that they have access.
     * @alias androiddeviceprovisioning.partners.customers.create
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.parent Required. The parent resource ID in the format `partners/[PARTNER_ID]` that identifies the reseller.
     * @param {().CreateCustomerRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    create(params?: any, options?: MethodOptions): AxiosPromise<Schema$Company>;
    create(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Company>, callback?: BodyResponseCallback<Schema$Company>): void;
    /**
     * androiddeviceprovisioning.partners.customers.list
     * @desc Lists the customers that are enrolled to the reseller identified by
     * the `partnerId` argument. This list includes customers that the reseller
     * created and customers that enrolled themselves using the portal.
     * @alias androiddeviceprovisioning.partners.customers.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$ListCustomersResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ListCustomersResponse>, callback?: BodyResponseCallback<Schema$ListCustomersResponse>): void;
}
export declare class Resource$Partners$Devices {
    root: Androiddeviceprovisioning;
    constructor(root: Androiddeviceprovisioning);
    getRoot(): Androiddeviceprovisioning;
    /**
     * androiddeviceprovisioning.partners.devices.claim
     * @desc Claims a device for a customer and adds it to zero-touch enrollment.
     * If the device is already claimed by another customer, the call returns an
     * error.
     * @alias androiddeviceprovisioning.partners.devices.claim
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {().ClaimDeviceRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    claim(params?: any, options?: MethodOptions): AxiosPromise<Schema$ClaimDeviceResponse>;
    claim(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ClaimDeviceResponse>, callback?: BodyResponseCallback<Schema$ClaimDeviceResponse>): void;
    /**
     * androiddeviceprovisioning.partners.devices.claimAsync
     * @desc Claims a batch of devices for a customer asynchronously. Adds the
     * devices to zero-touch enrollment. To learn more, read [Long‑running batch
     * operations](/zero-touch/guides/how-it-works#operations).
     * @alias androiddeviceprovisioning.partners.devices.claimAsync
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {().ClaimDevicesRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    claimAsync(params?: any, options?: MethodOptions): AxiosPromise<Schema$Operation>;
    claimAsync(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Operation>, callback?: BodyResponseCallback<Schema$Operation>): void;
    /**
     * androiddeviceprovisioning.partners.devices.findByIdentifier
     * @desc Finds devices by hardware identifiers, such as IMEI.
     * @alias androiddeviceprovisioning.partners.devices.findByIdentifier
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {().FindDevicesByDeviceIdentifierRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    findByIdentifier(params?: any, options?: MethodOptions): AxiosPromise<Schema$FindDevicesByDeviceIdentifierResponse>;
    findByIdentifier(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$FindDevicesByDeviceIdentifierResponse>, callback?: BodyResponseCallback<Schema$FindDevicesByDeviceIdentifierResponse>): void;
    /**
     * androiddeviceprovisioning.partners.devices.findByOwner
     * @desc Finds devices claimed for customers. The results only contain devices
     * registered to the reseller that's identified by the `partnerId` argument.
     * The customer's devices purchased from other resellers don't appear in the
     * results.
     * @alias androiddeviceprovisioning.partners.devices.findByOwner
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {().FindDevicesByOwnerRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    findByOwner(params?: any, options?: MethodOptions): AxiosPromise<Schema$FindDevicesByOwnerResponse>;
    findByOwner(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$FindDevicesByOwnerResponse>, callback?: BodyResponseCallback<Schema$FindDevicesByOwnerResponse>): void;
    /**
     * androiddeviceprovisioning.partners.devices.get
     * @desc Gets a device.
     * @alias androiddeviceprovisioning.partners.devices.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.name Required. The device API resource name in the format `partners/[PARTNER_ID]/devices/[DEVICE_ID]`.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Device>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Device>, callback?: BodyResponseCallback<Schema$Device>): void;
    /**
     * androiddeviceprovisioning.partners.devices.metadata
     * @desc Updates reseller metadata associated with the device.
     * @alias androiddeviceprovisioning.partners.devices.metadata
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.deviceId Required. The ID of the reseller partner.
     * @param {string} params.metadataOwnerId Required. The owner of the newly set metadata. Set this to the partner ID.
     * @param {().UpdateDeviceMetadataRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    metadata(params?: any, options?: MethodOptions): AxiosPromise<Schema$DeviceMetadata>;
    metadata(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$DeviceMetadata>, callback?: BodyResponseCallback<Schema$DeviceMetadata>): void;
    /**
     * androiddeviceprovisioning.partners.devices.unclaim
     * @desc Unclaims a device from a customer and removes it from zero-touch
     * enrollment.
     * @alias androiddeviceprovisioning.partners.devices.unclaim
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.partnerId Required. The ID of the reseller partner.
     * @param {().UnclaimDeviceRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    unclaim(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    unclaim(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * androiddeviceprovisionin