@googleapis/chromemanagement 2.0.0 → 3.0.0

package/v1.ts

@@ -12,7 +12,6 @@
 // limitations under the License.
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/class-name-casing */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 /* eslint-disable @typescript-eslint/no-namespace */
@@ -225,7 +224,7 @@ export namespace chromemanagement_v1 {
     type?: string | null;
   }
   /**
-   * Audio report.
+   * Status data for storage. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceAudioStatus](https://chromeenterprise.google/policies/#ReportDeviceAudioStatus) * Data Collection Frequency: 10 minutes * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1AudioStatusReport {
     /**
@@ -258,7 +257,7 @@ export namespace chromemanagement_v1 {
     reportTime?: string | null;
   }
   /**
-   * Battery info
+   * Information about the battery. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDevicePowerStatus](https://chromeenterprise.google/policies/#ReportDevicePowerStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1BatteryInfo {
     /**
@@ -287,7 +286,7 @@ export namespace chromemanagement_v1 {
     technology?: string | null;
   }
   /**
-   * Sampling data for battery.
+   * Sampling data for battery. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDevicePowerStatus](https://chromeenterprise.google/policies/#ReportDevicePowerStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1BatterySampleReport {
     /**
@@ -324,7 +323,7 @@ export namespace chromemanagement_v1 {
     voltage?: string | null;
   }
   /**
-   * Status data for battery.
+   * Status data for battery. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDevicePowerStatus](https://chromeenterprise.google/policies/#ReportDevicePowerStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1BatteryStatusReport {
     /**
@@ -352,6 +351,35 @@ export namespace chromemanagement_v1 {
      */
     serialNumber?: string | null;
   }
+  /**
+   * Boot performance report of a device. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceBootMode](https://chromeenterprise.google/policies/#ReportDeviceBootMode) * Data Collection Frequency: On every boot up event * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: N/A
+   */
+  export interface Schema$GoogleChromeManagementV1BootPerformanceReport {
+    /**
+     * Total time to boot up.
+     */
+    bootUpDuration?: string | null;
+    /**
+     * The timestamp when power came on.
+     */
+    bootUpTime?: string | null;
+    /**
+     * Timestamp when the report was collected.
+     */
+    reportTime?: string | null;
+    /**
+     * Total time since shutdown start to power off.
+     */
+    shutdownDuration?: string | null;
+    /**
+     * The shutdown reason.
+     */
+    shutdownReason?: string | null;
+    /**
+     * The timestamp when shutdown.
+     */
+    shutdownTime?: string | null;
+  }
   /**
    * Describes a browser version and its install count.
    */
@@ -389,6 +417,10 @@ export namespace chromemanagement_v1 {
      * Output only. Whether the app or extension is in a published state in the Chrome Web Store.
      */
     isCwsHosted?: boolean | null;
+    /**
+     * Output only. Whether an app supports policy for extensions.
+     */
+    isExtensionPolicySupported?: boolean | null;
     /**
      * Output only. Whether the app is only for Kiosk mode on ChromeOS devices
      */
@@ -494,6 +526,61 @@ export namespace chromemanagement_v1 {
      */
     totalSize?: number | null;
   }
+  /**
+   * Response containing a list of devices expiring in each month of a selected time frame. Counts are grouped by model and Auto Update Expiration date.
+   */
+  export interface Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse {
+    /**
+     * The list of reports sorted by auto update expiration date in ascending order.
+     */
+    deviceAueCountReports?: Schema$GoogleChromeManagementV1DeviceAueCountReport[];
+  }
+  /**
+   * Response containing counts for devices that need attention.
+   */
+  export interface Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse {
+    /**
+     * Number of ChromeOS devices have not synced policies in the past 28 days.
+     */
+    noRecentPolicySyncCount?: string | null;
+    /**
+     * Number of ChromeOS devices that have not seen any user activity in the past 28 days.
+     */
+    noRecentUserActivityCount?: string | null;
+    /**
+     * Number of devices whose OS version is not compliant.
+     */
+    osVersionNotCompliantCount?: string | null;
+    /**
+     * Number of devices that are pending an OS update.
+     */
+    pendingUpdate?: string | null;
+    /**
+     * Number of devices that are unable to apply a policy due to an OS version mismatch.
+     */
+    unsupportedPolicyCount?: string | null;
+  }
+  /**
+   * Response containing a list of devices with a specific type of hardware specification from the requested hardware type.
+   */
+  export interface Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse {
+    /**
+     * The DeviceHardwareCountReport for device cpu type (for example Intel(R) Core(TM) i7-10610U CPU @ 1.80GHz).
+     */
+    cpuReports?: Schema$GoogleChromeManagementV1DeviceHardwareCountReport[];
+    /**
+     * The DeviceHardwareCountReport for device memory amount in gigabytes (for example 16).
+     */
+    memoryReports?: Schema$GoogleChromeManagementV1DeviceHardwareCountReport[];
+    /**
+     * The DeviceHardwareCountReport for device model type (for example Acer C7 Chromebook).
+     */
+    modelReports?: Schema$GoogleChromeManagementV1DeviceHardwareCountReport[];
+    /**
+     * The DeviceHardwareCountReport for device storage amount in gigabytes (for example 128).
+     */
+    storageReports?: Schema$GoogleChromeManagementV1DeviceHardwareCountReport[];
+  }
   /**
    * Response containing requested browser versions details and counts.
    */
@@ -529,13 +616,21 @@ export namespace chromemanagement_v1 {
     totalSize?: number | null;
   }
   /**
-   * CPU specs for a CPU.
+   * CPU specifications for the device * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDeviceCpuInfo](https://chromeenterprise.google/policies/#ReportDeviceCpuInfo) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1CpuInfo {
     /**
-     * Output only. The CPU architecture.
+     * Output only. Architecture type for the CPU. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDeviceCpuInfo](https://chromeenterprise.google/policies/#ReportDeviceCpuInfo) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
      */
     architecture?: string | null;
+    /**
+     * Output only. Whether keylocker is configured.`TRUE` = Enabled; `FALSE` = disabled. Only reported if keylockerSupported = `TRUE`.
+     */
+    keylockerConfigured?: boolean | null;
+    /**
+     * Output only. Whether keylocker is supported.
+     */
+    keylockerSupported?: boolean | null;
     /**
      * Output only. The max CPU clock speed in kHz.
      */
@@ -546,7 +641,7 @@ export namespace chromemanagement_v1 {
     model?: string | null;
   }
   /**
-   * Contains samples of the cpu status reports.
+   * Provides information about the status of the CPU. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceCpuInfo](https://chromeenterprise.google/policies/#ReportDeviceCpuInfo) * Data Collection Frequency: Every 10 minutes * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1CpuStatusReport {
     /**
@@ -567,7 +662,7 @@ export namespace chromemanagement_v1 {
     sampleFrequency?: string | null;
   }
   /**
-   * CPU temperature of a device. Sampled per CPU core in Celsius
+   * CPU temperature of a device. Sampled per CPU core in Celsius. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceCpuInfo](https://chromeenterprise.google/policies/#ReportDeviceCpuInfo) * Data Collection Frequency: Every 10 minutes * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1CpuTemperatureInfo {
     /**
@@ -592,6 +687,44 @@ export namespace chromemanagement_v1 {
      */
     machine?: string | null;
   }
+  /**
+   * Report for CountChromeDevicesPerAueDateResponse, contains the count of devices of a specific model and auto update expiration range.
+   */
+  export interface Schema$GoogleChromeManagementV1DeviceAueCountReport {
+    /**
+     * Enum value of month corresponding to the auto update expiration date in UTC time zone. If the device is already expired, this field is empty.
+     */
+    aueMonth?: string | null;
+    /**
+     * Int value of year corresponding to the Auto Update Expiration date in UTC time zone. If the device is already expired, this field is empty.
+     */
+    aueYear?: string | null;
+    /**
+     * Count of devices of this model.
+     */
+    count?: string | null;
+    /**
+     * Boolean value for whether or not the device has already expired.
+     */
+    expired?: boolean | null;
+    /**
+     * Public model name of the devices.
+     */
+    model?: string | null;
+  }
+  /**
+   * Report for CountChromeDevicesPerHardwareSpecResponse, contains the count of devices with a unique hardware specification.
+   */
+  export interface Schema$GoogleChromeManagementV1DeviceHardwareCountReport {
+    /**
+     * Public name of the hardware specification.
+     */
+    bucket?: string | null;
+    /**
+     * Count of devices with a unique hardware specification.
+     */
+    count?: string | null;
+  }
   /**
    * Status of the single storage device.
    */
@@ -709,7 +842,7 @@ export namespace chromemanagement_v1 {
     driverVersion?: string | null;
   }
   /**
-   * Information of the graphics subsystem.
+   * Information of the graphics subsystem. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDeviceGraphicsStatus](https://chromeenterprise.google/policies/#ReportDeviceGraphicsStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1GraphicsInfo {
     /**
@@ -718,7 +851,7 @@ export namespace chromemanagement_v1 {
     adapterInfo?: Schema$GoogleChromeManagementV1GraphicsAdapterInfo;
   }
   /**
-   * Information of the graphics subsystem.
+   * Information of the graphics subsystem. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceGraphicsInfo](https://chromeenterprise.google/policies/#ReportDeviceGraphicsInfo) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1GraphicsStatusReport {
     /**
@@ -730,6 +863,19 @@ export namespace chromemanagement_v1 {
      */
     reportTime?: string | null;
   }
+  /**
+   * Data that describes the result of the HTTPS latency diagnostics routine, with the HTTPS requests issued to Google websites.
+   */
+  export interface Schema$GoogleChromeManagementV1HttpsLatencyRoutineData {
+    /**
+     * Output only. HTTPS latency if routine succeeded or failed because of HIGH_LATENCY or VERY_HIGH_LATENCY.
+     */
+    latency?: string | null;
+    /**
+     * Output only. HTTPS latency routine problem if a problem occurred.
+     */
+    problem?: string | null;
+  }
   /**
    * Describes an installed app.
    */
@@ -790,20 +936,24 @@ export namespace chromemanagement_v1 {
     nextPageToken?: string | null;
   }
   /**
-   * Memory information of a device.
+   * Memory information of a device. * This field has both telemetry and device information: - `totalRamBytes` - Device information - `availableRamBytes` - Telemetry information - `totalMemoryEncryption` - Device information * Data for this field is controlled via policy: [ReportDeviceMemoryInfo](https://chromeenterprise.google/policies/#ReportDeviceMemoryInfo) * Data Collection Frequency: - `totalRamBytes` - Only at upload - `availableRamBytes` - Every 10 minutes - `totalMemoryEncryption` - at device startup * Default Data Reporting Frequency: - `totalRamBytes` - 3 hours - `availableRamBytes` - 3 hours - `totalMemoryEncryption` - at device startup - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: only for `totalMemoryEncryption` * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1MemoryInfo {
     /**
      * Output only. Amount of available RAM in bytes.
      */
     availableRamBytes?: string | null;
+    /**
+     * Output only. Total memory encryption info for the device.
+     */
+    totalMemoryEncryption?: Schema$GoogleChromeManagementV1TotalMemoryEncryptionInfo;
     /**
      * Output only. Total RAM in bytes.
      */
     totalRamBytes?: string | null;
   }
   /**
-   * Contains samples of memory status reports.
+   * Contains samples of memory status reports. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceMemoryInfo](https://chromeenterprise.google/policies/#ReportDeviceMemoryInfo) * Data Collection Frequency: Only at upload, SystemRamFreeByes is collected every 10 minutes * Default Data Reporting Frequency: Every 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1MemoryStatusReport {
     /**
@@ -824,17 +974,88 @@ export namespace chromemanagement_v1 {
     systemRamFreeBytes?: string | null;
   }
   /**
-   * State of visible/configured networks.
+   * Details about the network device. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportNetworkDeviceConfiguration](https://chromeenterprise.google/policies/#ReportNetworkDeviceConfiguration) * Data Collection Frequency: At device startup * Default Data Reporting Frequency: At device startup - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: N/A
+   */
+  export interface Schema$GoogleChromeManagementV1NetworkDevice {
+    /**
+     * Output only. The integrated circuit card ID associated with the device's sim card.
+     */
+    iccid?: string | null;
+    /**
+     * Output only. IMEI (if applicable) of the corresponding network device.
+     */
+    imei?: string | null;
+    /**
+     * Output only. MAC address (if applicable) of the corresponding network device.
+     */
+    macAddress?: string | null;
+    /**
+     * Output only. The mobile directory number associated with the device's sim card.
+     */
+    mdn?: string | null;
+    /**
+     * Output only. MEID (if applicable) of the corresponding network device.
+     */
+    meid?: string | null;
+    /**
+     * Output only. Network device type.
+     */
+    type?: string | null;
+  }
+  /**
+   * Network testing results to determine the health of the device's network connection, for example whether the HTTPS latency is high or normal.
+   */
+  export interface Schema$GoogleChromeManagementV1NetworkDiagnosticsReport {
+    /**
+     * Output only. HTTPS latency test data.
+     */
+    httpsLatencyData?: Schema$GoogleChromeManagementV1HttpsLatencyRoutineData;
+    /**
+     * Output only. Timestamp of when the diagnostics were collected.
+     */
+    reportTime?: string | null;
+  }
+  /**
+   * Network device information. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportNetworkDeviceConfiguration](https://chromeenterprise.google/policies/#ReportNetworkDeviceConfiguration) * Data Collection Frequency: At device startup * Default Data Reporting Frequency: At device startup - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: N/A
+   */
+  export interface Schema$GoogleChromeManagementV1NetworkInfo {
+    /**
+     * Output only. List of network devices.
+     */
+    networkDevices?: Schema$GoogleChromeManagementV1NetworkDevice[];
+  }
+  /**
+   * State of visible/configured networks. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportNetworkStatus](https://chromeenterprise.google/policies/#ReportNetworkStatus) * Data Collection Frequency: 60 minutes * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: Yes
    */
   export interface Schema$GoogleChromeManagementV1NetworkStatusReport {
+    /**
+     * Output only. Current connection state of the network.
+     */
+    connectionState?: string | null;
+    /**
+     * Output only. Network connection type.
+     */
+    connectionType?: string | null;
+    /**
+     * Output only. Whether the wifi encryption key is turned off.
+     */
+    encryptionOn?: boolean | null;
     /**
      * Output only. Gateway IP address.
      */
     gatewayIpAddress?: string | null;
+    /**
+     * Output only. Network connection guid.
+     */
+    guid?: string | null;
     /**
      * Output only. LAN IP address.
      */
     lanIpAddress?: string | null;
+    /**
+     * Output only. Receiving bit rate measured in Megabits per second.
+     */
+    receivingBitRateMbps?: string | null;
     /**
      * Output only. Time at which the network state was reported.
      */
@@ -847,9 +1068,25 @@ export namespace chromemanagement_v1 {
      * Output only. Signal strength for wireless networks measured in decibels.
      */
     signalStrengthDbm?: number | null;
+    /**
+     * Output only. Transmission bit rate measured in Megabits per second.
+     */
+    transmissionBitRateMbps?: string | null;
+    /**
+     * Output only. Transmission power measured in decibels.
+     */
+    transmissionPowerDbm?: number | null;
+    /**
+     * Output only. Wifi link quality. Value ranges from [0, 70]. 0 indicates no signal and 70 indicates a strong signal.
+     */
+    wifiLinkQuality?: string | null;
+    /**
+     * Output only. Wifi power management enabled
+     */
+    wifiPowerManagementEnabled?: boolean | null;
   }
   /**
-   * Contains information regarding the current OS update status.
+   * Contains information regarding the current OS update status. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceOsUpdateStatus](https://chromeenterprise.google/policies/#ReportDeviceOsUpdateStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1OsUpdateStatus {
     /**
@@ -878,7 +1115,7 @@ export namespace chromemanagement_v1 {
     updateState?: string | null;
   }
   /**
-   * Status data for storage.
+   * Status data for storage. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceStorageStatus](https://chromeenterprise.google/policies/#ReportDeviceStorageStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1StorageInfo {
     /**
@@ -912,7 +1149,7 @@ export namespace chromemanagement_v1 {
     volumeId?: string | null;
   }
   /**
-   * Status data for storage.
+   * Status data for storage. * This field is telemetry information and this will change over time as the device is utilized. * Data for this field is controlled via policy: [ReportDeviceStorageStatus](https://chromeenterprise.google/policies/#ReportDeviceStorageStatus) * Data Collection Frequency: Only at Upload * Default Data Reporting Frequency: 3 hours - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: No * Reported for affiliated users only: N/A
    */
   export interface Schema$GoogleChromeManagementV1StorageStatusReport {
     /**
@@ -940,6 +1177,10 @@ export namespace chromemanagement_v1 {
      * Output only. Battery reports collected periodically.
      */
     batteryStatusReport?: Schema$GoogleChromeManagementV1BatteryStatusReport[];
+    /**
+     * Output only. Boot performance reports of the device.
+     */
+    bootPerformanceReport?: Schema$GoogleChromeManagementV1BootPerformanceReport[];
     /**
      * Output only. Information regarding CPU specs for the device.
      */
@@ -976,6 +1217,14 @@ export namespace chromemanagement_v1 {
      * Output only. Resource name of the device.
      */
     name?: string | null;
+    /**
+     * Output only. Network diagnostics collected periodically.
+     */
+    networkDiagnosticsReport?: Schema$GoogleChromeManagementV1NetworkDiagnosticsReport[];
+    /**
+     * Output only. Network devices information.
+     */
+    networkInfo?: Schema$GoogleChromeManagementV1NetworkInfo;
     /**
      * Output only. Network specs collected periodically.
      */
@@ -1000,6 +1249,40 @@ export namespace chromemanagement_v1 {
      * Output only. Storage reports collected periodically.
      */
     storageStatusReport?: Schema$GoogleChromeManagementV1StorageStatusReport[];
+    /**
+     * Output only. Information on Thunderbolt bus.
+     */
+    thunderboltInfo?: Schema$GoogleChromeManagementV1ThunderboltInfo[];
+  }
+  /**
+   * Thunderbolt bus info. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDeviceSecurityStatus](https://chromeenterprise.google/policies/#ReportDeviceSecurityStatus) * Data Collection Frequency: At device startup * Default Data Reporting Frequency: At device startup - Policy Controlled: No * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: N/A
+   */
+  export interface Schema$GoogleChromeManagementV1ThunderboltInfo {
+    /**
+     * Security level of the Thunderbolt bus.
+     */
+    securityLevel?: string | null;
+  }
+  /**
+   * Memory encryption information of a device. * This field provides device information, which is static and will not change over time. * Data for this field is controlled via policy: [ReportDeviceMemoryInfo](https://chromeenterprise.google/policies/#ReportDeviceMemoryInfo) * Data Collection Frequency: At device startup * Default Data Reporting Frequency: At device startup - Policy Controlled: Yes * Cache: If the device is offline, the collected data is stored locally, and will be reported when the device is next online: Yes * Reported for affiliated users only: N/A
+   */
+  export interface Schema$GoogleChromeManagementV1TotalMemoryEncryptionInfo {
+    /**
+     * Memory encryption algorithm.
+     */
+    encryptionAlgorithm?: string | null;
+    /**
+     * The state of memory encryption on the device.
+     */
+    encryptionState?: string | null;
+    /**
+     * The length of the encryption keys.
+     */
+    keyLength?: string | null;
+    /**
+     * The maximum number of keys that can be used for encryption.
+     */
+    maxKeys?: 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).
@@ -1755,6 +2038,460 @@ export namespace chromemanagement_v1 {
       this.context = context;
     }
 
+    /**
+     * Generate report of the number of devices expiring in each month of the selected time frame. Devices are grouped by auto update expiration date and model. Further information can be found [here](https://support.google.com/chrome/a/answer/10564947).
+     * @example
+     * ```js
+     * // Before running the sample:
+     * // - Enable the API at:
+     * //   https://console.developers.google.com/apis/api/chromemanagement.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 chromemanagement = google.chromemanagement('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: [
+     *       'https://www.googleapis.com/auth/chrome.management.reports.readonly',
+     *     ],
+     *   });
+     *
+     *   // 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 chromemanagement.customers.reports.countChromeDevicesReachingAutoExpirationDate(
+     *       {
+     *         // Required. The customer ID or "my_customer" prefixed with "customers/".
+     *         customer: 'customers/my-customer',
+     *         // Optional. Maximum expiration date in format yyyy-mm-dd in UTC timezone. If included returns all devices that have already expired and devices with auto expiration date equal to or earlier than the maximum date.
+     *         maxAueDate: 'placeholder-value',
+     *         // Optional. Maximum expiration date in format yyyy-mm-dd in UTC timezone. If included returns all devices that have already expired and devices with auto expiration date equal to or later than the minimum date.
+     *         minAueDate: 'placeholder-value',
+     *         // Optional. The organizational unit ID, if omitted, will return data for all organizational units.
+     *         orgUnitId: 'placeholder-value',
+     *       }
+     *     );
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "deviceAueCountReports": []
+     *   // }
+     * }
+     *
+     * 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.
+     */
+    countChromeDevicesReachingAutoExpirationDate(
+      params: Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    countChromeDevicesReachingAutoExpirationDate(
+      params?: Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>;
+    countChromeDevicesReachingAutoExpirationDate(
+      params: Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    countChromeDevicesReachingAutoExpirationDate(
+      params: Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+    ): void;
+    countChromeDevicesReachingAutoExpirationDate(
+      params: Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+    ): void;
+    countChromeDevicesReachingAutoExpirationDate(
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+    ): void;
+    countChromeDevicesReachingAutoExpirationDate(
+      paramsOrCallback?:
+        | Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl =
+        options.rootUrl || 'https://chromemanagement.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/v1/{+customer}/reports:countChromeDevicesReachingAutoExpirationDate'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['customer'],
+        pathParams: ['customer'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleChromeManagementV1CountChromeDevicesReachingAutoExpirationDateResponse>(
+          parameters
+        );
+      }
+    }
+
+    /**
+     * Counts of ChromeOS devices that have not synced policies or have lacked user activity in the past 28 days, are out of date, or are not complaint. Further information can be found here https://support.google.com/chrome/a/answer/10564947
+     * @example
+     * ```js
+     * // Before running the sample:
+     * // - Enable the API at:
+     * //   https://console.developers.google.com/apis/api/chromemanagement.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 chromemanagement = google.chromemanagement('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: [
+     *       'https://www.googleapis.com/auth/chrome.management.reports.readonly',
+     *     ],
+     *   });
+     *
+     *   // 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 chromemanagement.customers.reports.countChromeDevicesThatNeedAttention(
+     *       {
+     *         // Required. The customer ID or "my_customer" prefixed with "customers/".
+     *         customer: 'customers/my-customer',
+     *         // Optional. The ID of the organizational unit. If omitted, all data will be returned.
+     *         orgUnitId: 'placeholder-value',
+     *         // Required. Mask of the fields that should be populated in the returned report.
+     *         readMask: 'placeholder-value',
+     *       }
+     *     );
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "noRecentPolicySyncCount": "my_noRecentPolicySyncCount",
+     *   //   "noRecentUserActivityCount": "my_noRecentUserActivityCount",
+     *   //   "osVersionNotCompliantCount": "my_osVersionNotCompliantCount",
+     *   //   "pendingUpdate": "my_pendingUpdate",
+     *   //   "unsupportedPolicyCount": "my_unsupportedPolicyCount"
+     *   // }
+     * }
+     *
+     * 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.
+     */
+    countChromeDevicesThatNeedAttention(
+      params: Params$Resource$Customers$Reports$Countchromedevicesthatneedattention,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    countChromeDevicesThatNeedAttention(
+      params?: Params$Resource$Customers$Reports$Countchromedevicesthatneedattention,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>;
+    countChromeDevicesThatNeedAttention(
+      params: Params$Resource$Customers$Reports$Countchromedevicesthatneedattention,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    countChromeDevicesThatNeedAttention(
+      params: Params$Resource$Customers$Reports$Countchromedevicesthatneedattention,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+    ): void;
+    countChromeDevicesThatNeedAttention(
+      params: Params$Resource$Customers$Reports$Countchromedevicesthatneedattention,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+    ): void;
+    countChromeDevicesThatNeedAttention(
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+    ): void;
+    countChromeDevicesThatNeedAttention(
+      paramsOrCallback?:
+        | Params$Resource$Customers$Reports$Countchromedevicesthatneedattention
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Customers$Reports$Countchromedevicesthatneedattention;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Customers$Reports$Countchromedevicesthatneedattention;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl =
+        options.rootUrl || 'https://chromemanagement.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/v1/{+customer}/reports:countChromeDevicesThatNeedAttention'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['customer'],
+        pathParams: ['customer'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleChromeManagementV1CountChromeDevicesThatNeedAttentionResponse>(
+          parameters
+        );
+      }
+    }
+
+    /**
+     * Counts of devices with a specific hardware specification from the requested hardware type (for example model name, processor type). Further information can be found here https://support.google.com/chrome/a/answer/10564947
+     * @example
+     * ```js
+     * // Before running the sample:
+     * // - Enable the API at:
+     * //   https://console.developers.google.com/apis/api/chromemanagement.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 chromemanagement = google.chromemanagement('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: [
+     *       'https://www.googleapis.com/auth/chrome.management.reports.readonly',
+     *     ],
+     *   });
+     *
+     *   // 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 chromemanagement.customers.reports.countChromeHardwareFleetDevices({
+     *       // Required. The customer ID or "my_customer".
+     *       customer: 'customers/my-customer',
+     *       // Optional. The ID of the organizational unit. If omitted, all data will be returned.
+     *       orgUnitId: 'placeholder-value',
+     *       // Required. Mask of the fields that should be populated in the returned report.
+     *       readMask: 'placeholder-value',
+     *     });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "cpuReports": [],
+     *   //   "memoryReports": [],
+     *   //   "modelReports": [],
+     *   //   "storageReports": []
+     *   // }
+     * }
+     *
+     * 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.
+     */
+    countChromeHardwareFleetDevices(
+      params: Params$Resource$Customers$Reports$Countchromehardwarefleetdevices,
+      options: StreamMethodOptions
+    ): GaxiosPromise<Readable>;
+    countChromeHardwareFleetDevices(
+      params?: Params$Resource$Customers$Reports$Countchromehardwarefleetdevices,
+      options?: MethodOptions
+    ): GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>;
+    countChromeHardwareFleetDevices(
+      params: Params$Resource$Customers$Reports$Countchromehardwarefleetdevices,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    countChromeHardwareFleetDevices(
+      params: Params$Resource$Customers$Reports$Countchromehardwarefleetdevices,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+    ): void;
+    countChromeHardwareFleetDevices(
+      params: Params$Resource$Customers$Reports$Countchromehardwarefleetdevices,
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+    ): void;
+    countChromeHardwareFleetDevices(
+      callback: BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+    ): void;
+    countChromeHardwareFleetDevices(
+      paramsOrCallback?:
+        | Params$Resource$Customers$Reports$Countchromehardwarefleetdevices
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | GaxiosPromise<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>
+      | GaxiosPromise<Readable> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Customers$Reports$Countchromehardwarefleetdevices;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params =
+          {} as Params$Resource$Customers$Reports$Countchromehardwarefleetdevices;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl =
+        options.rootUrl || 'https://chromemanagement.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/v1/{+customer}/reports:countChromeHardwareFleetDevices'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['customer'],
+        pathParams: ['customer'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleChromeManagementV1CountChromeHardwareFleetDevicesResponse>(
+          parameters
+        );
+      }
+    }
+
     /**
      * Generate report of installed Chrome versions.
      * @example
@@ -2215,6 +2952,55 @@ export namespace chromemanagement_v1 {
     }
   }
 
+  export interface Params$Resource$Customers$Reports$Countchromedevicesreachingautoexpirationdate
+    extends StandardParameters {
+    /**
+     * Required. The customer ID or "my_customer" prefixed with "customers/".
+     */
+    customer?: string;
+    /**
+     * Optional. Maximum expiration date in format yyyy-mm-dd in UTC timezone. If included returns all devices that have already expired and devices with auto expiration date equal to or earlier than the maximum date.
+     */
+    maxAueDate?: string;
+    /**
+     * Optional. Maximum expiration date in format yyyy-mm-dd in UTC timezone. If included returns all devices that have already expired and devices with auto expiration date equal to or later than the minimum date.
+     */
+    minAueDate?: string;
+    /**
+     * Optional. The organizational unit ID, if omitted, will return data for all organizational units.
+     */
+    orgUnitId?: string;
+  }
+  export interface Params$Resource$Customers$Reports$Countchromedevicesthatneedattention
+    extends StandardParameters {
+    /**
+     * Required. The customer ID or "my_customer" prefixed with "customers/".
+     */
+    customer?: string;
+    /**
+     * Optional. The ID of the organizational unit. If omitted, all data will be returned.
+     */
+    orgUnitId?: string;
+    /**
+     * Required. Mask of the fields that should be populated in the returned report.
+     */
+    readMask?: string;
+  }
+  export interface Params$Resource$Customers$Reports$Countchromehardwarefleetdevices
+    extends StandardParameters {
+    /**
+     * Required. The customer ID or "my_customer".
+     */
+    customer?: string;
+    /**
+     * Optional. The ID of the organizational unit. If omitted, all data will be returned.
+     */
+    orgUnitId?: string;
+    /**
+     * Required. Mask of the fields that should be populated in the returned report.
+     */
+    readMask?: string;
+  }
   export interface Params$Resource$Customers$Reports$Countchromeversions
     extends StandardParameters {
     /**
@@ -2357,6 +3143,7 @@ export namespace chromemanagement_v1 {
      *   //   "audioStatusReport": [],
      *   //   "batteryInfo": [],
      *   //   "batteryStatusReport": [],
+     *   //   "bootPerformanceReport": [],
      *   //   "cpuInfo": [],
      *   //   "cpuStatusReport": [],
      *   //   "customer": "my_customer",
@@ -2366,12 +3153,15 @@ export namespace chromemanagement_v1 {
      *   //   "memoryInfo": {},
      *   //   "memoryStatusReport": [],
      *   //   "name": "my_name",
+     *   //   "networkDiagnosticsReport": [],
+     *   //   "networkInfo": {},
      *   //   "networkStatusReport": [],
      *   //   "orgUnitId": "my_orgUnitId",
      *   //   "osUpdateStatus": [],
      *   //   "serialNumber": "my_serialNumber",
      *   //   "storageInfo": {},
-     *   //   "storageStatusReport": []
+     *   //   "storageStatusReport": [],
+     *   //   "thunderboltInfo": []
      *   // }
      * }
      *