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

Google APIs Client Library for Node.js

/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace androiddeviceprovisioning_v1 {
    export interface Options extends GlobalOptions {
        version: 'v1';
    }
    interface StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
        /**
         * V1 error format.
         */
        '$.xgafv'?: string;
        /**
         * OAuth access token.
         */
        access_token?: string;
        /**
         * Data format for response.
         */
        alt?: string;
        /**
         * JSONP
         */
        callback?: string;
        /**
         * Selector specifying which fields to include in a partial response.
         */
        fields?: string;
        /**
         * API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
         */
        key?: string;
        /**
         * OAuth 2.0 token for the current user.
         */
        oauth_token?: string;
        /**
         * Returns response with indentations and line breaks.
         */
        prettyPrint?: boolean;
        /**
         * Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
         */
        quotaUser?: string;
        /**
         * Legacy upload protocol for media (e.g. "media", "multipart").
         */
        uploadType?: string;
        /**
         * Upload protocol for media (e.g. "raw", "multipart").
         */
        upload_protocol?: string;
    }
    /**
     * Android Device Provisioning Partner API
     *
     * Automates Android zero-touch enrollment for device resellers, customers, and EMMs.
     *
     * @example
     * ```js
     * const {google} = require('googleapis');
     * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
     * ```
     */
    export class Androiddeviceprovisioning {
        context: APIRequestContext;
        customers: Resource$Customers;
        operations: Resource$Operations;
        partners: Resource$Partners;
        constructor(options: GlobalOptions, google?: GoogleConfigurable);
    }
    /**
     * 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 | null;
        /**
         * Required. Required. The device identifier of the device to claim.
         */
        deviceIdentifier?: Schema$DeviceIdentifier;
        /**
         * Optional. The metadata to attach to the device.
         */
        deviceMetadata?: Schema$DeviceMetadata;
        /**
         * Required. The section type of the device's provisioning record.
         */
        sectionType?: string | null;
    }
    /**
     * Response message containing device id of the claim.
     */
    export interface Schema$ClaimDeviceResponse {
        /**
         * The device ID of the claimed device.
         */
        deviceId?: string | null;
        /**
         * The resource name of the device in the format `partners/[PARTNER_ID]/devices/[DEVICE_ID]`.
         */
        deviceName?: string | null;
    }
    /**
     * 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 reseller, vendor, or customer in the zero-touch reseller and customer APIs.
     */
    export interface Schema$Company {
        /**
         * Optional. Email address of customer's users in the admin role. Each email address must be associated with a Google Account.
         */
        adminEmails?: string[] | null;
        /**
         * Output only. The ID of the company. Assigned by the server.
         */
        companyId?: string | null;
        /**
         * Required. The name of the company. For example _XYZ Corp_. Displayed to the company's employees in the zero-touch enrollment portal.
         */
        companyName?: string | null;
        /**
         * Output only. The API resource name of the company. The resource name is one of the following formats: * `partners/[PARTNER_ID]/customers/[CUSTOMER_ID]` * `partners/[PARTNER_ID]/vendors/[VENDOR_ID]` * `partners/[PARTNER_ID]/vendors/[VENDOR_ID]/customers/[CUSTOMER_ID]` Assigned by the server.
         */
        name?: string | null;
        /**
         * Required. 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[] | null;
        /**
         * Output only. Whether any user from the company has accepted the latest Terms of Service (ToS). See TermsStatus.
         */
        termsStatus?: string | null;
    }
    /**
     * 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 | null;
        /**
         * Output only. The ID of the configuration. Assigned by the server.
         */
        configurationId?: string | null;
        /**
         * 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 | null;
        /**
         * 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 | null;
        /**
         * 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 | null;
        /**
         * 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 | null;
        /**
         * The JSON-formatted EMM provisioning extras that are passed to the DPC.
         */
        dpcExtras?: string | null;
        /**
         * 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 | null;
        /**
         * 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 | null;
        /**
         * Output only. The API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. Assigned by the server.
         */
        name?: string | null;
    }
    /**
     * 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 | null;
        /**
         * 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 | null;
    }
    /**
     * 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 | null;
    }
    /**
     * 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 | null;
        /**
         * Output only. The ID of the device. Assigned by the server.
         */
        deviceId?: string | null;
        /**
         * The hardware IDs that identify a manufactured device. To learn more, read [Identifiers](https://developers.google.com/zero-touch/guides/identifiers).
         */
        deviceIdentifier?: Schema$DeviceIdentifier;
        /**
         * The metadata attached to the device. Structured as key-value pairs. To learn more, read [Device metadata](https://developers.google.com/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 | null;
    }
    /**
     * 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 | null;
        /**
         * The ID of the reseller that claimed the device.
         */
        resellerId?: string | null;
        /**
         * Output only. The type of claim made on the device.
         */
        sectionType?: string | null;
        /**
         * The timestamp when the device will exit ‘vacation mode’. This value is present iff the device is in 'vacation mode'.
         */
        vacationModeExpireTime?: string | null;
        /**
         * The timestamp when the device was put into ‘vacation mode’. This value is present iff the device is in 'vacation mode'.
         */
        vacationModeStartTime?: string | null;
    }
    /**
     * Encapsulates hardware and product IDs to identify a manufactured device. To understand requirements on identifier sets, read [Identifiers](https://developers.google.com/zero-touch/guides/identifiers).
     */
    export interface Schema$DeviceIdentifier {
        /**
         * The device’s IMEI number. Validated on input.
         */
        imei?: string | null;
        /**
         * The device manufacturer’s name. Matches the device's built-in value returned from `android.os.Build.MANUFACTURER`. Allowed values are listed in [manufacturers](/zero-touch/resources/manufacturer-names#manufacturers-names).
         */
        manufacturer?: string | null;
        /**
         * The device’s MEID number.
         */
        meid?: string | null;
        /**
         * The device model's name. Matches the device's built-in value returned from `android.os.Build.MODEL`. Allowed values are listed in [models](/zero-touch/resources/manufacturer-names#model-names).
         */
        model?: string | null;
        /**
         * The manufacturer's serial number for the device. This value might not be unique across different device models.
         */
        serialNumber?: string | null;
    }
    /**
     * Metadata entries that can be attached to a `Device`. To learn more, read [Device metadata](https://developers.google.com/zero-touch/guides/metadata).
     */
    export interface Schema$DeviceMetadata {
        /**
         * Metadata entries recorded as key-value pairs.
         */
        entries?: {
            [key: string]: string;
        } | null;
    }
    /**
     * 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](https://developers.google.com/zero-touch/guides/identifiers).
     */
    export interface Schema$DeviceReference {
        /**
         * The ID of the device.
         */
        deviceId?: string | null;
        /**
         * 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 | null;
        /**
         * The processing status of the operation.
         */
        processingStatus?: string | null;
        /**
         * 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 | null;
    }
    /**
     * 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 | null;
    }
    /**
     * An EMM's DPC ([device policy controller](http://developer.android.com/work/dpc/build-dpc.html)). 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 | null;
        /**
         * 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 | null;
        /**
         * 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 | null;
    }
    /**
     * 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. 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 | null;
        /**
         * A token specifying which result page to return.
         */
        pageToken?: string | null;
    }
    /**
     * 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 | null;
        /**
         * The total count of items in the list irrespective of pagination.
         */
        totalSize?: number | null;
    }
    /**
     * Request to find devices by customers.
     */
    export interface Schema$FindDevicesByOwnerRequest {
        /**
         * Required. The list of customer IDs to search for.
         */
        customerId?: string[] | null;
        /**
         * Required. The maximum number of devices to show in a page of results. Must be between 1 and 100 inclusive.
         */
        limit?: string | null;
        /**
         * A token specifying which result page to return.
         */
        pageToken?: string | null;
        /**
         * Required. The section type of the device's provisioning record.
         */
        sectionType?: string | null;
    }
    /**
     * 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 | null;
        /**
         * The total count of items in the list irrespective of pagination.
         */
        totalSize?: number | null;
    }
    /**
     * Response message of all customers related to this partner.
     */
    export interface Schema$ListCustomersResponse {
        /**
         * List of customers related to this reseller partner.
         */
        customers?: Schema$Company[];
        /**
         * A token to retrieve the next page of results. Omitted if no further results are available.
         */
        nextPageToken?: string | null;
        /**
         * The total count of items in the list irrespective of pagination.
         */
        totalSize?: number | null;
    }
    /**
     * Response message to list customers of the vendor.
     */
    export interface Schema$ListVendorCustomersResponse {
        /**
         * List of customers of the vendor.
         */
        customers?: Schema$Company[];
        /**
         * A token to retrieve the next page of results. Omitted if no further results are available.
         */
        nextPageToken?: string | null;
        /**
         * The total count of items in the list irrespective of pagination.
         */
        totalSize?: number | null;
    }
    /**
     * Response message to list vendors of the partner.
     */
    export interface Schema$ListVendorsResponse {
        /**
         * A token to retrieve the next page of results. Omitted if no further results are available.
         */
        nextPageToken?: string | null;
        /**
         * The total count of items in the list irrespective of pagination.
         */
        totalSize?: number | null;
        /**
         * List of vendors of the reseller partner. Fields `name`, `companyId` and `companyName` are populated to the Company object.
         */
        vendors?: 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 | null;
        /**
         * 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?: {
            [key: string]: any;
        } | null;
        /**
         * The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id\}`.
         */
        name?: string | null;
        /**
         * This field will contain a `DevicesLongRunningOperationResponse` object if the operation is created by `claimAsync`, `unclaimAsync`, or `updateMetadataAsync`.
         */
        response?: {
            [key: string]: any;
        } | null;
    }
    /**
     * 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 | null;
        /**
         * Required. 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 | null;
    }
    /**
     * Identifies one unclaim request.
     */
    export interface Schema$PartnerUnclaim {
        /**
         * Required. Device ID of the device.
         */
        deviceId?: string | null;
        /**
         * Required. Device identifier of the device.
         */
        deviceIdentifier?: Schema$DeviceIdentifier;
        /**
         * Required. The section type of the device's provisioning record.
         */
        sectionType?: string | null;
        /**
         * Optional. The duration of the vacation unlock starting from when the request is processed. (1 day is treated as 24 hours)
         */
        vacationModeDays?: number | null;
        /**
         * Optional. The expiration time of the vacation unlock.
         */
        vacationModeExpireTime?: string | null;
    }
    /**
     * 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 | null;
        /**
         * If processing fails, the error type.
         */
        errorIdentifier?: string | null;
        /**
         * If processing fails, a developer message explaining what went wrong.
         */
        errorMessage?: string | null;
        /**
         * The result status of the device after processing.
         */
        status?: string | null;
    }
    /**
     * The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
     */
    export interface Schema$Status {
        /**
         * The status code, which should be an enum value of google.rpc.Code.
         */
        code?: number | null;
        /**
         * A list of messages that carry the error details. There is a common set of message types for APIs to use.
         */
        details?: Array<{
            [key: string]: any;
        }> | null;
        /**
         * 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 | null;
    }
    /**
     * Request message to unclaim a device.
     */
    export interface Schema$UnclaimDeviceRequest {
        /**
         * Required. The device ID returned by `ClaimDevice`.
         */
        deviceId?: string | null;
        /**
         * Required. 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 | null;
        /**
         * The duration of the vacation unlock starting from when the request is processed. (1 day is treated as 24 hours)
         */
        vacationModeDays?: number | null;
        /**
         * The expiration time of the vacation unlock.
         */
        vacationModeExpireTime?: string | null;
    }
    /**
     * 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 metadata to attach to the device.
         */
        deviceMetadata?: Schema$DeviceMetadata;
    }
    /**
     * Identifies metadata updates to one device.
     */
    export interface Schema$UpdateMetadataArguments {
        /**
         * Required. Device ID of the device.
         */
        deviceId?: string | null;
        /**
         * Required. Device identifier.
         */
        deviceIdentifier?: Schema$DeviceIdentifier;
        /**
         * Required. The metadata to update.
         */
        deviceMetadata?: Schema$DeviceMetadata;
    }
    export class Resource$Customers {
        context: APIRequestContext;
        configurations: Resource$Customers$Configurations;
        devices: Resource$Customers$Devices;
        dpcs: Resource$Customers$Dpcs;
        constructor(context: APIRequestContext);
        /**
         * Lists the user's customer accounts.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.list({
         *     // The maximum number of customers to show in a page of results. A number between 1 and 100 (inclusive).
         *     pageSize: 'placeholder-value',
         *     // A token specifying which result page to return.
         *     pageToken: 'placeholder-value',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "customers": [],
         *   //   "nextPageToken": "my_nextPageToken"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Customers$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Customers$List, options?: MethodOptions): GaxiosPromise<Schema$CustomerListCustomersResponse>;
        list(params: Params$Resource$Customers$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Customers$List, options: MethodOptions | BodyResponseCallback<Schema$CustomerListCustomersResponse>, callback: BodyResponseCallback<Schema$CustomerListCustomersResponse>): void;
        list(params: Params$Resource$Customers$List, callback: BodyResponseCallback<Schema$CustomerListCustomersResponse>): void;
        list(callback: BodyResponseCallback<Schema$CustomerListCustomersResponse>): void;
    }
    export interface Params$Resource$Customers$List extends StandardParameters {
        /**
         * The maximum number of customers to show in a page of results. A number between 1 and 100 (inclusive).
         */
        pageSize?: number;
        /**
         * A token specifying which result page to return.
         */
        pageToken?: string;
    }
    export class Resource$Customers$Configurations {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * Creates a new configuration. Once created, a customer can apply the configuration to devices.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.configurations.create({
         *     // Required. The customer that manages the configuration. An API resource name in the format `customers/[CUSTOMER_ID]`.
         *     parent: 'customers/my-customer',
         *
         *     // Request body metadata
         *     requestBody: {
         *       // request body parameters
         *       // {
         *       //   "companyName": "my_companyName",
         *       //   "configurationId": "my_configurationId",
         *       //   "configurationName": "my_configurationName",
         *       //   "contactEmail": "my_contactEmail",
         *       //   "contactPhone": "my_contactPhone",
         *       //   "customMessage": "my_customMessage",
         *       //   "dpcExtras": "my_dpcExtras",
         *       //   "dpcResourcePath": "my_dpcResourcePath",
         *       //   "isDefault": false,
         *       //   "name": "my_name"
         *       // }
         *     },
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "companyName": "my_companyName",
         *   //   "configurationId": "my_configurationId",
         *   //   "configurationName": "my_configurationName",
         *   //   "contactEmail": "my_contactEmail",
         *   //   "contactPhone": "my_contactPhone",
         *   //   "customMessage": "my_customMessage",
         *   //   "dpcExtras": "my_dpcExtras",
         *   //   "dpcResourcePath": "my_dpcResourcePath",
         *   //   "isDefault": false,
         *   //   "name": "my_name"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        create(params: Params$Resource$Customers$Configurations$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
        create(params?: Params$Resource$Customers$Configurations$Create, options?: MethodOptions): GaxiosPromise<Schema$Configuration>;
        create(params: Params$Resource$Customers$Configurations$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        create(params: Params$Resource$Customers$Configurations$Create, options: MethodOptions | BodyResponseCallback<Schema$Configuration>, callback: BodyResponseCallback<Schema$Configuration>): void;
        create(params: Params$Resource$Customers$Configurations$Create, callback: BodyResponseCallback<Schema$Configuration>): void;
        create(callback: BodyResponseCallback<Schema$Configuration>): void;
        /**
         * Deletes an unused configuration. The API call fails if the customer has devices with the configuration applied.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.configurations.delete({
         *     // 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.
         *     name: 'customers/my-customer/configurations/my-configuration',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {}
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        delete(params: Params$Resource$Customers$Configurations$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
        delete(params?: Params$Resource$Customers$Configurations$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
        delete(params: Params$Resource$Customers$Configurations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        delete(params: Params$Resource$Customers$Configurations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
        delete(params: Params$Resource$Customers$Configurations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
        delete(callback: BodyResponseCallback<Schema$Empty>): void;
        /**
         * Gets the details of a configuration.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.configurations.get({
         *     // Required. The configuration to get. An API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`.
         *     name: 'customers/my-customer/configurations/my-configuration',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "companyName": "my_companyName",
         *   //   "configurationId": "my_configurationId",
         *   //   "configurationName": "my_configurationName",
         *   //   "contactEmail": "my_contactEmail",
         *   //   "contactPhone": "my_contactPhone",
         *   //   "customMessage": "my_customMessage",
         *   //   "dpcExtras": "my_dpcExtras",
         *   //   "dpcResourcePath": "my_dpcResourcePath",
         *   //   "isDefault": false,
         *   //   "name": "my_name"
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        get(params: Params$Resource$Customers$Configurations$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
        get(params?: Params$Resource$Customers$Configurations$Get, options?: MethodOptions): GaxiosPromise<Schema$Configuration>;
        get(params: Params$Resource$Customers$Configurations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        get(params: Params$Resource$Customers$Configurations$Get, options: MethodOptions | BodyResponseCallback<Schema$Configuration>, callback: BodyResponseCallback<Schema$Configuration>): void;
        get(params: Params$Resource$Customers$Configurations$Get, callback: BodyResponseCallback<Schema$Configuration>): void;
        get(callback: BodyResponseCallback<Schema$Configuration>): void;
        /**
         * Lists a customer's configurations.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.configurations.list({
         *     // Required. The customer that manages the listed configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
         *     parent: 'customers/my-customer',
         *   });
         *   console.log(res.data);
         *
         *   // Example response
         *   // {
         *   //   "configurations": []
         *   // }
         * }
         *
         * main().catch(e => {
         *   console.error(e);
         *   throw e;
         * });
         *
         * ```
         *
         * @param params - Parameters for request
         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
         * @param callback - Optional callback that handles the response.
         * @returns A promise if used with async/await, or void if used with a callback.
         */
        list(params: Params$Resource$Customers$Configurations$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
        list(params?: Params$Resource$Customers$Configurations$List, options?: MethodOptions): GaxiosPromise<Schema$CustomerListConfigurationsResponse>;
        list(params: Params$Resource$Customers$Configurations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
        list(params: Params$Resource$Customers$Configurations$List, options: MethodOptions | BodyResponseCallback<Schema$CustomerListConfigurationsResponse>, callback: BodyResponseCallback<Schema$CustomerListConfigurationsResponse>): void;
        list(params: Params$Resource$Customers$Configurations$List, callback: BodyResponseCallback<Schema$CustomerListConfigurationsResponse>): void;
        list(callback: BodyResponseCallback<Schema$CustomerListConfigurationsResponse>): void;
        /**
         * Updates a configuration's field values.
         * @example
         * ```js
         * // Before running the sample:
         * // - Enable the API at:
         * //   https://console.developers.google.com/apis/api/androiddeviceprovisioning.googleapis.com
         * // - Login into gcloud by running:
         * //   `$ gcloud auth application-default login`
         * // - Install the npm module by running:
         * //   `$ npm install googleapis`
         *
         * const {google} = require('googleapis');
         * const androiddeviceprovisioning = google.androiddeviceprovisioning('v1');
         *
         * async function main() {
         *   const auth = new google.auth.GoogleAuth({
         *     // Scopes can be specified either as an array or as a single, space-delimited string.
         *     scopes: [],
         *   });
         *
         *   // Acquire an auth client, and bind it to all future calls
         *   const authClient = await auth.getClient();
         *   google.options({auth: authClient});
         *
         *   // Do the magic
         *   const res = await androiddeviceprovisioning.customers.configurations.patch({
         *     // Output only. The API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. Assigned by the server.
         *     name: 'customers/my-customer/configurations/my-configuration',
         *     // 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.
         *     updateMask: 'placeholder-value',
         *
         *     // Request bod