///
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;
list(params?: Params$Resource$Customers$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Customers$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): 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;
create(params?: Params$Resource$Customers$Configurations$Create, options?: MethodOptions): GaxiosPromise;
create(params: Params$Resource$Customers$Configurations$Create, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
create(params: Params$Resource$Customers$Configurations$Create, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
create(params: Params$Resource$Customers$Configurations$Create, callback: BodyResponseCallback): void;
create(callback: BodyResponseCallback): 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;
delete(params?: Params$Resource$Customers$Configurations$Delete, options?: MethodOptions): GaxiosPromise;
delete(params: Params$Resource$Customers$Configurations$Delete, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
delete(params: Params$Resource$Customers$Configurations$Delete, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
delete(params: Params$Resource$Customers$Configurations$Delete, callback: BodyResponseCallback): void;
delete(callback: BodyResponseCallback): 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;
get(params?: Params$Resource$Customers$Configurations$Get, options?: MethodOptions): GaxiosPromise;
get(params: Params$Resource$Customers$Configurations$Get, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Customers$Configurations$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Customers$Configurations$Get, callback: BodyResponseCallback): void;
get(callback: BodyResponseCallback): 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;
list(params?: Params$Resource$Customers$Configurations$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Customers$Configurations$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Configurations$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Configurations$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): 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 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.
*/
patch(params: Params$Resource$Customers$Configurations$Patch, options: StreamMethodOptions): GaxiosPromise;
patch(params?: Params$Resource$Customers$Configurations$Patch, options?: MethodOptions): GaxiosPromise;
patch(params: Params$Resource$Customers$Configurations$Patch, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
patch(params: Params$Resource$Customers$Configurations$Patch, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
patch(params: Params$Resource$Customers$Configurations$Patch, callback: BodyResponseCallback): void;
patch(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Customers$Configurations$Create extends StandardParameters {
/**
* Required. The customer that manages the configuration. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$Configuration;
}
export interface Params$Resource$Customers$Configurations$Delete extends StandardParameters {
/**
* 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?: string;
}
export interface Params$Resource$Customers$Configurations$Get extends StandardParameters {
/**
* Required. The configuration to get. An API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`.
*/
name?: string;
}
export interface Params$Resource$Customers$Configurations$List extends StandardParameters {
/**
* Required. The customer that manages the listed configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
}
export interface Params$Resource$Customers$Configurations$Patch extends StandardParameters {
/**
* Output only. The API resource name in the format `customers/[CUSTOMER_ID]/configurations/[CONFIGURATION_ID]`. Assigned by the server.
*/
name?: string;
/**
* 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?: string;
/**
* Request body metadata
*/
requestBody?: Schema$Configuration;
}
export class Resource$Customers$Devices {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* 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.
* @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.devices.applyConfiguration(
* {
* // Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
* parent: 'customers/my-customer',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "configuration": "my_configuration",
* // "device": {}
* // }
* },
* }
* );
* 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.
*/
applyConfiguration(params: Params$Resource$Customers$Devices$Applyconfiguration, options: StreamMethodOptions): GaxiosPromise;
applyConfiguration(params?: Params$Resource$Customers$Devices$Applyconfiguration, options?: MethodOptions): GaxiosPromise;
applyConfiguration(params: Params$Resource$Customers$Devices$Applyconfiguration, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
applyConfiguration(params: Params$Resource$Customers$Devices$Applyconfiguration, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
applyConfiguration(params: Params$Resource$Customers$Devices$Applyconfiguration, callback: BodyResponseCallback): void;
applyConfiguration(callback: BodyResponseCallback): void;
/**
* Gets the details of a device.
* @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.devices.get({
* // Required. The device to get. An API resource name in the format `customers/[CUSTOMER_ID]/devices/[DEVICE_ID]`.
* name: 'customers/my-customer/devices/my-device',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "claims": [],
* // "configuration": "my_configuration",
* // "deviceId": "my_deviceId",
* // "deviceIdentifier": {},
* // "deviceMetadata": {},
* // "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$Devices$Get, options: StreamMethodOptions): GaxiosPromise;
get(params?: Params$Resource$Customers$Devices$Get, options?: MethodOptions): GaxiosPromise;
get(params: Params$Resource$Customers$Devices$Get, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Customers$Devices$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Customers$Devices$Get, callback: BodyResponseCallback): void;
get(callback: BodyResponseCallback): void;
/**
* Lists a customer's 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.devices.list({
* // The maximum number of devices to show in a page of results. Must be between 1 and 100 inclusive.
* pageSize: 'placeholder-value',
* // A token specifying which result page to return.
* pageToken: 'placeholder-value',
* // Required. The customer managing the devices. An API resource name in the format `customers/[CUSTOMER_ID]`.
* parent: 'customers/my-customer',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "devices": [],
* // "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$Devices$List, options: StreamMethodOptions): GaxiosPromise;
list(params?: Params$Resource$Customers$Devices$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Customers$Devices$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Devices$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Devices$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): void;
/**
* Removes a configuration from device.
* @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.devices.removeConfiguration(
* {
* // Required. The customer managing the device in the format `customers/[CUSTOMER_ID]`.
* parent: 'customers/my-customer',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "device": {}
* // }
* },
* }
* );
* 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.
*/
removeConfiguration(params: Params$Resource$Customers$Devices$Removeconfiguration, options: StreamMethodOptions): GaxiosPromise;
removeConfiguration(params?: Params$Resource$Customers$Devices$Removeconfiguration, options?: MethodOptions): GaxiosPromise;
removeConfiguration(params: Params$Resource$Customers$Devices$Removeconfiguration, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
removeConfiguration(params: Params$Resource$Customers$Devices$Removeconfiguration, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
removeConfiguration(params: Params$Resource$Customers$Devices$Removeconfiguration, callback: BodyResponseCallback): void;
removeConfiguration(callback: BodyResponseCallback): void;
/**
* 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.
* @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.devices.unclaim({
* // Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
* parent: 'customers/my-customer',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "device": {}
* // }
* },
* });
* 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.
*/
unclaim(params: Params$Resource$Customers$Devices$Unclaim, options: StreamMethodOptions): GaxiosPromise;
unclaim(params?: Params$Resource$Customers$Devices$Unclaim, options?: MethodOptions): GaxiosPromise;
unclaim(params: Params$Resource$Customers$Devices$Unclaim, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaim(params: Params$Resource$Customers$Devices$Unclaim, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaim(params: Params$Resource$Customers$Devices$Unclaim, callback: BodyResponseCallback): void;
unclaim(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Customers$Devices$Applyconfiguration extends StandardParameters {
/**
* Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$CustomerApplyConfigurationRequest;
}
export interface Params$Resource$Customers$Devices$Get extends StandardParameters {
/**
* Required. The device to get. An API resource name in the format `customers/[CUSTOMER_ID]/devices/[DEVICE_ID]`.
*/
name?: string;
}
export interface Params$Resource$Customers$Devices$List extends StandardParameters {
/**
* The maximum number of devices to show in a page of results. Must be between 1 and 100 inclusive.
*/
pageSize?: string;
/**
* A token specifying which result page to return.
*/
pageToken?: string;
/**
* Required. The customer managing the devices. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
}
export interface Params$Resource$Customers$Devices$Removeconfiguration extends StandardParameters {
/**
* Required. The customer managing the device in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$CustomerRemoveConfigurationRequest;
}
export interface Params$Resource$Customers$Devices$Unclaim extends StandardParameters {
/**
* Required. The customer managing the device. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$CustomerUnclaimDeviceRequest;
}
export class Resource$Customers$Dpcs {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* Lists the DPCs (device policy controllers) that support zero-touch enrollment.
* @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.dpcs.list({
* // Required. The customer that can use the DPCs in configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
* parent: 'customers/my-customer',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "dpcs": []
* // }
* }
*
* 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$Dpcs$List, options: StreamMethodOptions): GaxiosPromise;
list(params?: Params$Resource$Customers$Dpcs$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Customers$Dpcs$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Dpcs$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Customers$Dpcs$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Customers$Dpcs$List extends StandardParameters {
/**
* Required. The customer that can use the DPCs in configurations. An API resource name in the format `customers/[CUSTOMER_ID]`.
*/
parent?: string;
}
export class Resource$Operations {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* 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.
* @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.operations.get({
* // The name of the operation resource.
* name: 'operations/.*',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "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.
*/
get(params: Params$Resource$Operations$Get, options: StreamMethodOptions): GaxiosPromise;
get(params?: Params$Resource$Operations$Get, options?: MethodOptions): GaxiosPromise;
get(params: Params$Resource$Operations$Get, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Operations$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Operations$Get, callback: BodyResponseCallback): void;
get(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Operations$Get extends StandardParameters {
/**
* The name of the operation resource.
*/
name?: string;
}
export class Resource$Partners {
context: APIRequestContext;
customers: Resource$Partners$Customers;
devices: Resource$Partners$Devices;
vendors: Resource$Partners$Vendors;
constructor(context: APIRequestContext);
}
export class Resource$Partners$Customers {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* 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 customer receives an email that welcomes them to zero-touch enrollment and explains how to sign into the portal.
* @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.partners.customers.create({
* // Required. The parent resource ID in the format `partners/[PARTNER_ID]` that identifies the reseller.
* parent: 'partners/my-partner',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "customer": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "adminEmails": [],
* // "companyId": "my_companyId",
* // "companyName": "my_companyName",
* // "name": "my_name",
* // "ownerEmails": [],
* // "termsStatus": "my_termsStatus"
* // }
* }
*
* 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$Partners$Customers$Create, options: StreamMethodOptions): GaxiosPromise;
create(params?: Params$Resource$Partners$Customers$Create, options?: MethodOptions): GaxiosPromise;
create(params: Params$Resource$Partners$Customers$Create, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
create(params: Params$Resource$Partners$Customers$Create, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
create(params: Params$Resource$Partners$Customers$Create, callback: BodyResponseCallback): void;
create(callback: BodyResponseCallback): void;
/**
* 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.
* @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.partners.customers.list({
* // The maximum number of results to be returned. If not specified or 0, all the records are returned.
* pageSize: 'placeholder-value',
* // A token identifying a page of results returned by the server.
* pageToken: 'placeholder-value',
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "customers": [],
* // "nextPageToken": "my_nextPageToken",
* // "totalSize": 0
* // }
* }
*
* 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$Partners$Customers$List, options: StreamMethodOptions): GaxiosPromise;
list(params?: Params$Resource$Partners$Customers$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Partners$Customers$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Customers$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Customers$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Partners$Customers$Create extends StandardParameters {
/**
* Required. The parent resource ID in the format `partners/[PARTNER_ID]` that identifies the reseller.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$CreateCustomerRequest;
}
export interface Params$Resource$Partners$Customers$List extends StandardParameters {
/**
* The maximum number of results to be returned. If not specified or 0, all the records are returned.
*/
pageSize?: number;
/**
* A token identifying a page of results returned by the server.
*/
pageToken?: string;
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
}
export class Resource$Partners$Devices {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* 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.
* @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.partners.devices.claim({
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "customerId": "my_customerId",
* // "deviceIdentifier": {},
* // "deviceMetadata": {},
* // "sectionType": "my_sectionType"
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "deviceId": "my_deviceId",
* // "deviceName": "my_deviceName"
* // }
* }
*
* 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.
*/
claim(params: Params$Resource$Partners$Devices$Claim, options: StreamMethodOptions): GaxiosPromise;
claim(params?: Params$Resource$Partners$Devices$Claim, options?: MethodOptions): GaxiosPromise;
claim(params: Params$Resource$Partners$Devices$Claim, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
claim(params: Params$Resource$Partners$Devices$Claim, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
claim(params: Params$Resource$Partners$Devices$Claim, callback: BodyResponseCallback): void;
claim(callback: BodyResponseCallback): void;
/**
* 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).
* @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.partners.devices.claimAsync({
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "claims": []
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "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.
*/
claimAsync(params: Params$Resource$Partners$Devices$Claimasync, options: StreamMethodOptions): GaxiosPromise;
claimAsync(params?: Params$Resource$Partners$Devices$Claimasync, options?: MethodOptions): GaxiosPromise;
claimAsync(params: Params$Resource$Partners$Devices$Claimasync, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
claimAsync(params: Params$Resource$Partners$Devices$Claimasync, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
claimAsync(params: Params$Resource$Partners$Devices$Claimasync, callback: BodyResponseCallback): void;
claimAsync(callback: BodyResponseCallback): void;
/**
* Finds devices by hardware identifiers, such as IMEI.
* @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.partners.devices.findByIdentifier(
* {
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "deviceIdentifier": {},
* // "limit": "my_limit",
* // "pageToken": "my_pageToken"
* // }
* },
* }
* );
* console.log(res.data);
*
* // Example response
* // {
* // "devices": [],
* // "nextPageToken": "my_nextPageToken",
* // "totalSize": 0
* // }
* }
*
* 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.
*/
findByIdentifier(params: Params$Resource$Partners$Devices$Findbyidentifier, options: StreamMethodOptions): GaxiosPromise;
findByIdentifier(params?: Params$Resource$Partners$Devices$Findbyidentifier, options?: MethodOptions): GaxiosPromise;
findByIdentifier(params: Params$Resource$Partners$Devices$Findbyidentifier, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
findByIdentifier(params: Params$Resource$Partners$Devices$Findbyidentifier, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
findByIdentifier(params: Params$Resource$Partners$Devices$Findbyidentifier, callback: BodyResponseCallback): void;
findByIdentifier(callback: BodyResponseCallback): void;
/**
* 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.
* @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.partners.devices.findByOwner({
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "customerId": [],
* // "limit": "my_limit",
* // "pageToken": "my_pageToken",
* // "sectionType": "my_sectionType"
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "devices": [],
* // "nextPageToken": "my_nextPageToken",
* // "totalSize": 0
* // }
* }
*
* 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.
*/
findByOwner(params: Params$Resource$Partners$Devices$Findbyowner, options: StreamMethodOptions): GaxiosPromise;
findByOwner(params?: Params$Resource$Partners$Devices$Findbyowner, options?: MethodOptions): GaxiosPromise;
findByOwner(params: Params$Resource$Partners$Devices$Findbyowner, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
findByOwner(params: Params$Resource$Partners$Devices$Findbyowner, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
findByOwner(params: Params$Resource$Partners$Devices$Findbyowner, callback: BodyResponseCallback): void;
findByOwner(callback: BodyResponseCallback): void;
/**
* Gets a device.
* @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.partners.devices.get({
* // Required. The device API resource name in the format `partners/[PARTNER_ID]/devices/[DEVICE_ID]`.
* name: 'partners/my-partner/devices/my-device',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "claims": [],
* // "configuration": "my_configuration",
* // "deviceId": "my_deviceId",
* // "deviceIdentifier": {},
* // "deviceMetadata": {},
* // "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$Partners$Devices$Get, options: StreamMethodOptions): GaxiosPromise;
get(params?: Params$Resource$Partners$Devices$Get, options?: MethodOptions): GaxiosPromise;
get(params: Params$Resource$Partners$Devices$Get, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Partners$Devices$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
get(params: Params$Resource$Partners$Devices$Get, callback: BodyResponseCallback): void;
get(callback: BodyResponseCallback): void;
/**
* Updates reseller metadata associated with the device.
* @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.partners.devices.metadata({
* // Required. The ID of the device.
* deviceId: '[^/]+',
* // Required. The owner of the newly set metadata. Set this to the partner ID.
* metadataOwnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "deviceMetadata": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "entries": {}
* // }
* }
*
* 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.
*/
metadata(params: Params$Resource$Partners$Devices$Metadata, options: StreamMethodOptions): GaxiosPromise;
metadata(params?: Params$Resource$Partners$Devices$Metadata, options?: MethodOptions): GaxiosPromise;
metadata(params: Params$Resource$Partners$Devices$Metadata, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
metadata(params: Params$Resource$Partners$Devices$Metadata, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
metadata(params: Params$Resource$Partners$Devices$Metadata, callback: BodyResponseCallback): void;
metadata(callback: BodyResponseCallback): void;
/**
* Unclaims a device from a customer and removes it from zero-touch enrollment.
* @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.partners.devices.unclaim({
* // Required. The ID of the reseller partner.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "deviceId": "my_deviceId",
* // "deviceIdentifier": {},
* // "sectionType": "my_sectionType",
* // "vacationModeDays": 0,
* // "vacationModeExpireTime": "my_vacationModeExpireTime"
* // }
* },
* });
* 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.
*/
unclaim(params: Params$Resource$Partners$Devices$Unclaim, options: StreamMethodOptions): GaxiosPromise;
unclaim(params?: Params$Resource$Partners$Devices$Unclaim, options?: MethodOptions): GaxiosPromise;
unclaim(params: Params$Resource$Partners$Devices$Unclaim, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaim(params: Params$Resource$Partners$Devices$Unclaim, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaim(params: Params$Resource$Partners$Devices$Unclaim, callback: BodyResponseCallback): void;
unclaim(callback: BodyResponseCallback): void;
/**
* Unclaims a batch of devices for a customer asynchronously. Removes the devices from zero-touch enrollment. To learn more, read [Long‑running batch operations](/zero-touch/guides/how-it-works#operations).
* @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.partners.devices.unclaimAsync({
* // Required. The reseller partner ID.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "unclaims": []
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "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.
*/
unclaimAsync(params: Params$Resource$Partners$Devices$Unclaimasync, options: StreamMethodOptions): GaxiosPromise;
unclaimAsync(params?: Params$Resource$Partners$Devices$Unclaimasync, options?: MethodOptions): GaxiosPromise;
unclaimAsync(params: Params$Resource$Partners$Devices$Unclaimasync, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaimAsync(params: Params$Resource$Partners$Devices$Unclaimasync, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
unclaimAsync(params: Params$Resource$Partners$Devices$Unclaimasync, callback: BodyResponseCallback): void;
unclaimAsync(callback: BodyResponseCallback): void;
/**
* Updates the reseller metadata attached to a batch of devices. This method updates devices asynchronously and returns an `Operation` that can be used to track progress. Read [Long‑running batch operations](/zero-touch/guides/how-it-works#operations).
* @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.partners.devices.updateMetadataAsync(
* {
* // Required. The reseller partner ID.
* partnerId: '[^/]+',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "updates": []
* // }
* },
* }
* );
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "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.
*/
updateMetadataAsync(params: Params$Resource$Partners$Devices$Updatemetadataasync, options: StreamMethodOptions): GaxiosPromise;
updateMetadataAsync(params?: Params$Resource$Partners$Devices$Updatemetadataasync, options?: MethodOptions): GaxiosPromise;
updateMetadataAsync(params: Params$Resource$Partners$Devices$Updatemetadataasync, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
updateMetadataAsync(params: Params$Resource$Partners$Devices$Updatemetadataasync, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
updateMetadataAsync(params: Params$Resource$Partners$Devices$Updatemetadataasync, callback: BodyResponseCallback): void;
updateMetadataAsync(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Partners$Devices$Claim extends StandardParameters {
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ClaimDeviceRequest;
}
export interface Params$Resource$Partners$Devices$Claimasync extends StandardParameters {
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ClaimDevicesRequest;
}
export interface Params$Resource$Partners$Devices$Findbyidentifier extends StandardParameters {
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$FindDevicesByDeviceIdentifierRequest;
}
export interface Params$Resource$Partners$Devices$Findbyowner extends StandardParameters {
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$FindDevicesByOwnerRequest;
}
export interface Params$Resource$Partners$Devices$Get extends StandardParameters {
/**
* Required. The device API resource name in the format `partners/[PARTNER_ID]/devices/[DEVICE_ID]`.
*/
name?: string;
}
export interface Params$Resource$Partners$Devices$Metadata extends StandardParameters {
/**
* Required. The ID of the device.
*/
deviceId?: string;
/**
* Required. The owner of the newly set metadata. Set this to the partner ID.
*/
metadataOwnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$UpdateDeviceMetadataRequest;
}
export interface Params$Resource$Partners$Devices$Unclaim extends StandardParameters {
/**
* Required. The ID of the reseller partner.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$UnclaimDeviceRequest;
}
export interface Params$Resource$Partners$Devices$Unclaimasync extends StandardParameters {
/**
* Required. The reseller partner ID.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$UnclaimDevicesRequest;
}
export interface Params$Resource$Partners$Devices$Updatemetadataasync extends StandardParameters {
/**
* Required. The reseller partner ID.
*/
partnerId?: string;
/**
* Request body metadata
*/
requestBody?: Schema$UpdateDeviceMetadataInBatchRequest;
}
export class Resource$Partners$Vendors {
context: APIRequestContext;
customers: Resource$Partners$Vendors$Customers;
constructor(context: APIRequestContext);
/**
* Lists the vendors of the partner.
* @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.partners.vendors.list({
* // The maximum number of results to be returned.
* pageSize: 'placeholder-value',
* // A token identifying a page of results returned by the server.
* pageToken: 'placeholder-value',
* // Required. The resource name in the format `partners/[PARTNER_ID]`.
* parent: 'partners/my-partner',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "nextPageToken": "my_nextPageToken",
* // "totalSize": 0,
* // "vendors": []
* // }
* }
*
* 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$Partners$Vendors$List, options: StreamMethodOptions): GaxiosPromise;
list(params?: Params$Resource$Partners$Vendors$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Partners$Vendors$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Vendors$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Vendors$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Partners$Vendors$List extends StandardParameters {
/**
* The maximum number of results to be returned.
*/
pageSize?: number;
/**
* A token identifying a page of results returned by the server.
*/
pageToken?: string;
/**
* Required. The resource name in the format `partners/[PARTNER_ID]`.
*/
parent?: string;
}
export class Resource$Partners$Vendors$Customers {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* Lists the customers of the vendor.
* @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.partners.vendors.customers.list({
* // The maximum number of results to be returned.
* pageSize: 'placeholder-value',
* // A token identifying a page of results returned by the server.
* pageToken: 'placeholder-value',
* // Required. The resource name in the format `partners/[PARTNER_ID]/vendors/[VENDOR_ID]`.
* parent: 'partners/my-partner/vendors/my-vendor',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "customers": [],
* // "nextPageToken": "my_nextPageToken",
* // "totalSize": 0
* // }
* }
*
* 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$Partners$Vendors$Customers$List, options: StreamMethodOptions): GaxiosPromise;
list(params?: Params$Resource$Partners$Vendors$Customers$List, options?: MethodOptions): GaxiosPromise;
list(params: Params$Resource$Partners$Vendors$Customers$List, options: StreamMethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Vendors$Customers$List, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback): void;
list(params: Params$Resource$Partners$Vendors$Customers$List, callback: BodyResponseCallback): void;
list(callback: BodyResponseCallback): void;
}
export interface Params$Resource$Partners$Vendors$Customers$List extends StandardParameters {
/**
* The maximum number of results to be returned.
*/
pageSize?: number;
/**
* A token identifying a page of results returned by the server.
*/
pageToken?: string;
/**
* Required. The resource name in the format `partners/[PARTNER_ID]/vendors/[VENDOR_ID]`.
*/
parent?: string;
}
export {};
}
//# sourceMappingURL=v1.d.ts.map