ESET PROTECT On-Prem

Offline | Onlinemodus

ESET PROTECT On-Prem – Inhaltsverzeichnis

# Move device

URL des aktuellen Artikels kopieren Per E-Mail teilen

Relative path: /v1/devices/{deviceUuid}:move

Move [Device] under new [Group].

It is possible to move Groups only in the scope of the same tenant.
The assignment of policies is updated according to the new hierarchy.

### Body example

{ "newParentUuid": "6bce8028-f9de-4f94-8765-d79443ec6bf7" }

### Request body

Display Schema instead of an Example or vice-versa

Type | Required | Example | Schema
--- | --- | --- | ---
application/json | Yes |
    {
      "newParentUuid": "string"
    }
    {
      "$ref": "DevicesMoveDeviceBody",
      "newParentUuid": {
        "type": "string",
        "description": "Reference to the new parent [Group] for the [Device] being moved. type: DeviceGroup"
      }
    }

### Parameters in path

Name | Type | Required | Description
--- | --- | --- | ---
deviceUuid | string | Yes | Reference to the [Device] to move. type: Device

### Responses

Display Schema+Headers instead of an Example or vice-versa

Code | Description and Example | Description, Schema and Headers
--- | --- | ---
200 | A successful response. Response example
    {
      "device": {
        "activeProducts": [
          {
            "activateDate": {
              "year": 0,
              "month": 0,
              "day": 0
            },
            "subscriptionUuid": "string",
            "unitPoolUuid": "string",
            "validityDate": {
              "year": 0,
              "month": 0,
              "day": 0
            },
            "id": 0,
            "name": "string"
          }
        ],
        "deployedComponents": [
          {
            "displayName": "string",
            "version": {
              "id": "string",
              "major": 0,
              "minor": 0,
              "name": "string",
              "patch": 0
            },
            "id": 0,
            "name": "string"
          }
        ],
        "description": "string",
        "deviceToken": "string",
        "deviceType": "DEVICE_TYPE_UNSPECIFIED",
        "displayName": "string",
        "enrollmentStatus": "DEVICE_ENROLLMENT_STATUS_UNSPECIFIED",
        "functionalityProblemCount": 0,
        "functionalityStatus": "DEVICE_FUNCTIONALITY_STATUS_UNSPECIFIED",
        "hardwareProfiles": [
          {
            "bios": {
              "manufacturer": "string",
              "serialNumber": "string",
              "uuid": "string"
            },
            "hardDrives": [
              {
                "capacityBytes": "string",
                "displayName": "string",
                "driveType": "DRIVE_TYPE_UNSPECIFIED",
                "hardwareEncryptionSupported": true,
                "malformedData": "string",
                "manufacturerName": "string",
                "serialNumber": "string"
              }
            ],
            "malformedData": "string",
            "manufacturer": "string",
            "model": "string",
            "networkAdapters": [
              {
                "caption": "string",
                "macAddress": "string",
                "malformedData": "string"
              }
            ],
            "processors": [
              {
                "architecture": "CPU_ARCHITECTURE_UNSPECIFIED",
                "caption": "string",
                "id": "string",
                "malformedData": "string",
                "manufacturer": "string"
              }
            ],
            "resettableIdentifier": "string",
            "salt": "string"
          }
        ],
        "isMaster": true,
        "isMobile": true,
        "isMuted": true,
        "lastSyncTime": "string",
        "managementDomain": "string",
        "cloningConfiguration": {
          "cloneNamingPatterns": [
            "string"
          ],
          "securityGroupUuid": "string",
          "securityGroupDisplayName": "string"
        },
        "operatingSystem": {
          "bitness": 0,
          "displayName": "string",
          "editionId": 0,
          "familyId": 0,
          "version": {
            "id": "string",
            "major": 0,
            "minor": 0,
            "name": "string",
            "patch": 0
          }
        },
        "originalDisplayName": "string",
        "parentGroupUuid": "string",
        "primaryLocalIpAddress": "string",
        "publicIpAddress": "string",
        "tags": [
          "string"
        ],
        "uuid": "string",
        "etag": "string",
        "ownerUuid": "string"
      }
    }
| A successful response. Response schema
    {
      "$ref": "v1MoveDeviceResponse",
      "device": {
        "$ref": "v1Device",
        "description": {
          "type": "string",
          "description": "Device description."
        },
        "activeProducts": [
          {
            "$ref": "v1ActiveDeviceProduct",
            "description": "A product activated on device. For example ESET Mobile Security product is activated on device.",
            "activateDate": {
              "$ref": "typeDate",
              "description": "A full date, with non-zero year, month, and day values A month and day value, with a zero year, such as an anniversary A year on its own, with zero month and day values A year and month value, with a zero day, such as a credit card expiration date Related types are [google.type.TimeOfDay][google.type.TimeOfDay] and google.protobuf.Timestamp.",
              "year": {
                "type": "integer",
                "description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.",
                "format": "int32"
              },
              "month": {
                "type": "integer",
                "description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.",
                "format": "int32"
              },
              "day": {
                "type": "integer",
                "description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.",
                "format": "int32"
              }
            },
            "subscriptionUuid": {
              "type": "string",
              "description": "Reference to [subscription], used for product activation. type: subscription_management.v1.Subscription"
            },
            "unitPoolUuid": {
              "type": "string",
              "description": "Reference to [unit pool], used for product activation. Unit pools contain units available for product activation. type: unit_management.v1.UnitPool"
            },
            "validityDate": {
              "$ref": "typeDate",
              "description": "A full date, with non-zero year, month, and day values A month and day value, with a zero year, such as an anniversary A year on its own, with zero month and day values A year and month value, with a zero day, such as a credit card expiration date Related types are [google.type.TimeOfDay][google.type.TimeOfDay] and google.protobuf.Timestamp.",
              "year": {
                "type": "integer",
                "description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.",
                "format": "int32"
              },
              "month": {
                "type": "integer",
                "description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.",
                "format": "int32"
              },
              "day": {
                "type": "integer",
                "description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.",
                "format": "int32"
              }
            },
            "id": {
              "type": "integer",
              "description": "Identifier of the governed resource. Can be seen as a value of item in enumerated type. It can be derived from the name by some algorithm, such as CRC32.",
              "format": "int64"
            },
            "name": {
              "type": "string",
              "description": "Name of the governed item. Can be seen as a name of an enumeration item, with id being its numerical value. Note: Not to be confused with display_name, which is purposed for UI."
            }
          }
        ],
        "deployedComponents": [
          {
            "$ref": "v1PlatformComponent",
            "description": "Descriptor of platform component with version. Info: Should we track modules, they will be here.",
            "displayName": {
              "type": "string",
              "description": "Human readable name of the component. Derived from package display_name.",
              "readOnly": true
            },
            "version": {
              "$ref": "v1Version",
              "description": "Version descriptor. Both values are required to completely reconstruct version information.",
              "id": {
                "type": "string",
                "description": "[Version id] determines whether one version is more recent than another. More recent versions have higher numbers. Can be processed by machine. If human readable version_name meets certain criteria, it can be converted to version_id automatically. The cases are: Windows => VersionId = MajorVersion << 48 | MinorVersion << 32 | ServicePackMajor << 24 | ServicePackMinor << 16 | CurrentBuildNumber Android => VersionId = API level YYYYMMDD => VersionId = (YYYY & 0xffff ) << 48 | (MM & 0xffff) << 32 | (DD & 0xffff) <<16 YYYY.MM => VersionId = (YYYY & 0xffff ) << 48 | (MM & 0xffff) << 32 YY.MM => VersionId = (YY & 0xffff ) << 48 | (MM & 0xffff) << 32 YYYY => VersionId = (YYYY & 0xffff ) << 48 Major.Minor.Patch => VersionId = (Major & 0xffff ) << 48 | (Minor & 0xffff) << 32 | (Patch & 0xffff) <<16 EULA | Terms of Use => VersionId = MajorVersion << 48 | MinorVersion << 32 | Patch << 16 A.B.C.D => VersionId = (A & 0xffff) << 48 | (B & 0xffff) << 32 | (C & 0xffff) << 16 | (D & 0xffff) A.B.C => VersionId = (A & 0xffff ) << 48 | (B & 0xffff) << 32 | (C & 0xffff) <<16 A.B => VersionId = (A & 0xffff ) << 48 | (B & 0xffff) << 32 A => VersionId = (A & 0xffff ) << 48",
                "format": "uint64"
              },
              "major": {
                "type": "integer",
                "description": "Major version if and only if version name adheres to semantic versioning. 0 or null otherwise.",
                "format": "int64",
                "readOnly": true
              },
              "minor": {
                "type": "integer",
                "description": "Minor version if and only if version name adheres to semantic versioning. 0 or null otherwise.",
                "format": "int64",
                "readOnly": true
              },
              "name": {
                "type": "string",
                "description": "Human readable name of the version. E.g. '10.2.3.145'"
              },
              "patch": {
                "type": "integer",
                "description": "Patch if and only if version name adheres to semantic versioning. 0 or null otherwise.",
                "format": "int64",
                "readOnly": true
              }
            },
            "id": {
              "type": "integer",
              "description": "Identifier of the governed resource. Can be seen as a value of item in enumerated type. It can be derived from the name by some algorithm, such as CRC32.",
              "format": "int64"
            },
            "name": {
              "type": "string",
              "description": "Name of the governed item. Can be seen as a name of an enumeration item, with id being its numerical value. Note: Not to be confused with display_name, which is purposed for UI."
            }
          }
        ],
        "deviceToken": {
          "title": "Identity token for the device",
          "type": "string",
          "readOnly": true
        },
        "deviceType": {
          "$ref": "v1DeviceType",
          "type": "string",
          "description": "Represents the type or category of a device. This enum is used to classify devices into predefined categories. DEVICE_TYPE_UNSPECIFIED: fallback DEVICE_TYPE_SMARTPHONE: Handheld device primarily used for communication, apps, and multimedia. DEVICE_TYPE_NOTEBOOK: Portable computer designed for personal or professional tasks. DEVICE_TYPE_IOT: Connected smart device, such as a smart thermostat or smart light bulb. DEVICE_TYPE_TABLET: Touchscreen device larger than a smartphone but smaller than a laptop. DEVICE_TYPE_DESKTOP: Stationary computer typically used in offices or as a personal workstation. DEVICE_TYPE_SMART_TV: Television with integrated internet and interactive features for streaming. DEVICE_TYPE_WEARABLE: Device worn on the body, such as a smartwatch or fitness tracker. DEVICE_TYPE_GAMING_CONSOLE: Device designed for playing video games, such as PlayStation or Xbox. DEVICE_TYPE_ROUTER: Networking device that forwards data packets between computer networks, including internetworks such as the global Internet. DEVICE_TYPE_PRINTER: Device used for printing documents, including home or office printers. DEVICE_TYPE_SECURITY_CAMERA: Camera used for surveillance and security monitoring. DEVICE_TYPE_VIRTUAL_MACHINE: Software-based instance that emulates a physical device. DEVICE_TYPE_SERVER: Device used in enterprise or data center environments to host services. DEVICE_TYPE_SMART_SPEAKER: Voice-activated speaker with integrated assistant features, like Amazon Echo.",
          "enum": [
            "DEVICE_TYPE_UNSPECIFIED",
            "DEVICE_TYPE_SMARTPHONE",
            "DEVICE_TYPE_NOTEBOOK",
            "DEVICE_TYPE_IOT",
            "DEVICE_TYPE_TABLET",
            "DEVICE_TYPE_DESKTOP",
            "DEVICE_TYPE_SMART_TV",
            "DEVICE_TYPE_WEARABLE",
            "DEVICE_TYPE_GAMING_CONSOLE",
            "DEVICE_TYPE_ROUTER",
            "DEVICE_TYPE_PRINTER",
            "DEVICE_TYPE_SECURITY_CAMERA",
            "DEVICE_TYPE_VIRTUAL_MACHINE",
            "DEVICE_TYPE_SERVER",
            "DEVICE_TYPE_SMART_SPEAKER"
          ]
        },
        "displayName": {
          "title": "Name given by the user to identify the device",
          "type": "string"
        },
        "enrollmentStatus": {
          "$ref": "v1DeviceEnrollmentStatus",
          "type": "string",
          "description": "Devices are enrolled in a process with managed devices being fully enrolled. DEVICE_ENROLLMENT_STATUS_UNSPECIFIED: Status is unknown. DEVICE_ENROLLMENT_STATUS_PENDING: The device is not enrolled yet. This status is typical for: - placeholder devices created for the enrollment links to be generated later on - devices just imported from other device managements - rogue devices discovered in the network - DEVICE_ENROLLMENT_STATUS_FINISHED: Enrollment is finished and the device can be managed. - DEVICE_ENROLLMENT_STATUS_FAILED: Enrollment process started, but failed.",
          "enum": [
            "DEVICE_ENROLLMENT_STATUS_UNSPECIFIED",
            "DEVICE_ENROLLMENT_STATUS_PENDING",
            "DEVICE_ENROLLMENT_STATUS_FINISHED",
            "DEVICE_ENROLLMENT_STATUS_FAILED"
          ]
        },
        "functionalityProblemCount": {
          "type": "integer",
          "description": "Aggregated count of functionality problems or issues on the device, regardless of their security risk.",
          "format": "int64",
          "readOnly": true
        },
        "functionalityStatus": {
          "$ref": "v1DeviceFunctionalityStatus",
          "type": "string",
          "description": "The functionality status is determined by the severity of the worst issue currently occurring on the device. DEVICE_FUNCTIONALITY_STATUS_UNSPECIFIED: fallback DEVICE_FUNCTIONALITY_STATUS_OK: The device is functioning normally, with no issues that require attention. DEVICE_FUNCTIONALITY_STATUS_ATTENTION_RECOMMENDED: There are issues that may not be critical (for example, medium security risks), but they should be addressed to avoid potential future problems. DEVICE_FUNCTIONALITY_STATUS_ATTENTION_REQUIRED: Critical issues exist (for example, severe security risks), and immediate action is necessary to maintain system integrity or security.",
          "enum": [
            "DEVICE_FUNCTIONALITY_STATUS_UNSPECIFIED",
            "DEVICE_FUNCTIONALITY_STATUS_OK",
            "DEVICE_FUNCTIONALITY_STATUS_ATTENTION_RECOMMENDED",
            "DEVICE_FUNCTIONALITY_STATUS_ATTENTION_REQUIRED"
          ]
        },
        "hardwareProfiles": [
          {
            "$ref": "v1Hardware",
            "description": "It can also be used to uniquely identify the device within the pool of all devices seen by ESET. Warning: For the fingerprint use-case, the values must be anonymized by using [SHA-256] hash and passed as 7-bit ASCII strings (containing only hexadecimal numbers and dashes possibly). This is a GDPR requirement.",
            "bios": {
              "$ref": "v1Bios",
              "description": "Information about BIOS (or UEFI in later systems).",
              "manufacturer": {
                "title": "BIOS manufacturer",
                "type": "string",
                "description": "For example, value LENOVO obtained by calling: wmic path win32_computersystemproduct get vendor"
              },
              "serialNumber": {
                "title": "BIOS serial number",
                "type": "string",
                "description": "For example, value MP10DQAF obtained by calling: wmic path win32_computersystemproduct get IdentifyingNumber"
              },
              "uuid": {
                "title": "UUID of BIOS",
                "type": "string",
                "description": "For example, value 99AAEECC-2C47-12CC-F85C-A0080C7BDC23 obtained by calling: wmic path win32_computersystemproduct get uuid"
              }
            },
            "hardDrives": [
              {
                "$ref": "v1HardDrive",
                "description": "Descriptor of hard drive.",
                "capacityBytes": {
                  "type": "string",
                  "description": "Use EIC multiples for conversion. For example, 500GB would be represented as 500 * 1024 * 1024 * 1024 bytes.",
                  "format": "uint64"
                },
                "displayName": {
                  "type": "string",
                  "description": "Human-readable name of the drive, such as 'Seagate Barracuda 2TB' or 'Samsung EVO 970 1TB SSD'."
                },
                "driveType": {
                  "$ref": "v1DriveType",
                  "type": "string",
                  "description": "Specifies the type of the drive, categorizing storage devices based on their underlying technology and functionality. DRIVE_TYPE_UNSPECIFIED: fallback DRIVE_TYPE_HDD: Hard Disk Drive (for example, traditional spinning disk drives used in desktops and servers). DRIVE_TYPE_SSD: Solid State Drive (for example, high-speed flash-based storage used in modern laptops). DRIVE_TYPE_OPTICAL: Optical Drive (for example, CD, DVD, or Blu-ray drives used for reading and writing discs).",
                  "enum": [
                    "DRIVE_TYPE_UNSPECIFIED",
                    "DRIVE_TYPE_HDD",
                    "DRIVE_TYPE_SSD",
                    "DRIVE_TYPE_OPTICAL"
                  ]
                },
                "hardwareEncryptionSupported": {
                  "type": "boolean",
                  "description": "Indicates whether the drive supports encryption. For instance, built-in AES-256 encryption."
                },
                "malformedData": {
                  "type": "string",
                  "description": "List of singular attributes where reading failed or returned a strange value. For more information about FiledMask usage, see Protocol Buffers Documentation: FieldMask"
                },
                "manufacturerName": {
                  "type": "string",
                  "description": "The company that manufactured the drive, such as 'Western Digital', 'Seagate', or 'Kingston'."
                },
                "serialNumber": {
                  "title": "Drive serial number",
                  "type": "string",
                  "description": "For example, value 0025_3865_6AE0_AF38 obtained by calling: wmic diskdrive get SerialNumber"
                }
              }
            ],
            "malformedData": {
              "type": "string",
              "description": "List of singular attributes where reading failed or returned a strange value. Info: FieldMask cannot address array members, so it must be present in every nested repeated field. In case of this message: hard_drives, network_adapters and processors have their nested masks too. For more information about FieldMask usage, refer to Protocol Buffers Documentation: FieldMask"
            },
            "manufacturer": {
              "title": "Vendor of the hardware",
              "type": "string"
            },
            "model": {
              "title": "Model identifier of the hardware",
              "type": "string"
            },
            "networkAdapters": [
              {
                "$ref": "v1NetworkAdapter",
                "description": "Descriptor of network adapter. It can also be a virtual adapter (e.g. VPN).",
                "caption": {
                  "title": "Name of adapter",
                  "type": "string",
                  "description": "For example, value Intel(R) Dual Band Wireless-AC 8260 obtained by calling: wmic nic get Caption"
                },
                "macAddress": {
                  "title": "MAC address - can be changed manually",
                  "type": "string",
                  "description": "For example, value 24:3A:21:52:41:53 obtained by calling: wmic nic get MACAddress"
                },
                "malformedData": {
                  "type": "string",
                  "description": "List of singular attributes where reading failed or returned a strange value. For more information about FiledMask usage, see Protocol Buffers Documentation: FieldMask"
                }
              }
            ],
            "processors": [
              {
                "$ref": "v1Processor",
                "description": "Descriptor of CPU.",
                "architecture": {
                  "$ref": "v1CpuArchitecture",
                  "title": "Processor architecture",
                  "type": "string",
                  "description": "Note: Cannot be named ProcessorArchitecture because of the conflict with Windows SDK, winnt.h, BUILD Version 0072. Series of macros prefixed PROCESSOR_ARCHITECTURE at line 12703 partially eclipse proto definition. Moreover, UKNOWN value is of value 0xffff, which makes it incompatible with the proto requirement to have it 0x0000. CPU_ARCHITECTURE_UNSPECIFIED: fallback CPU_ARCHITECTURE_X86: 32-bit x86 architecture CPU_ARCHITECTURE_X64: 64-bit x86 architecture CPU_ARCHITECTURE_ARM32: 32-bit ARM architecture CPU_ARCHITECTURE_ARM64: 64-bit ARM architecture",
                  "enum": [
                    "CPU_ARCHITECTURE_UNSPECIFIED",
                    "CPU_ARCHITECTURE_X86",
                    "CPU_ARCHITECTURE_X64",
                    "CPU_ARCHITECTURE_ARM32",
                    "CPU_ARCHITECTURE_ARM64"
                  ]
                },
                "caption": {
                  "title": "CPU/GPU name",
                  "type": "string",
                  "description": "For example, value Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz obtained by calling: wmic cpu get Name"
                },
                "id": {
                  "title": "wmic cpu get ProcessorId",
                  "type": "string",
                  "description": "ProcessorId"
                },
                "malformedData": {
                  "type": "string",
                  "description": "List of singular attributes where reading failed or returned a strange value. Info: FieldMask cannot address array members, so it must be present in every nested repeated field. For more information about FieldMask usage, see Protocol Buffers Documentation: FieldMask"
                },
                "manufacturer": {
                  "title": "CPU/GPU vendor",
                  "type": "string",
                  "description": "For example, value GenuineIntel obtained by calling: wmic cpu get manufacturer"
                }
              }
            ],
            "resettableIdentifier": {
              "type": "string",
              "description": "Resettable hardware identifier (for example, might not survive factory reset). Some operating systems do not provide access to non-resettable hardware identifiers at all, or they do in a restricted manner. For more information, see: Best practices for working with Android identifiers or Apple Developer Documentation: identifierForVendor"
            },
            "salt": {
              "title": "Salt used for unreliable hardware to make it visible among other unreliable hardware",
              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
              "type": "string",
              "format": "byte"
            }
          }
        ],
        "isMaster": {
          "type": "boolean",
          "description": "Indicates whether the device is designated as a master device. A master device can be used as the source for creating or cloning other virtual machines."
        },
        "isMobile": {
          "type": "boolean",
          "description": "The device is marked as mobile. A mobile device is a portable handheld computer small enough to be carried easily, which can function without being physically connected to a network and power source."
        },
        "isMuted": {
          "type": "boolean",
          "description": "It defines whether the device is Muted or not. Muted devices are purposed to not attract user's attention, even if they reach a noteworthy state (for example, they report a functionality problem). In practice that means they might get excluded from dashboards or lists. Default value: false - means the device is not muted.",
          "readOnly": true
        },
        "lastSyncTime": {
          "type": "string",
          "description": "When the device was synchronized for the last time. For remote management, this time also means LastSeenTime, LastActiveTime, LastConnectTime etc.",
          "format": "date-time",
          "readOnly": true
        },
        "managementDomain": {
          "type": "string",
          "description": "It provides affiliation mapping between devices and the accounts they belong to, regardless of the originating system (ESMC, EPC, ECA, Home...). It enables tenant binding, ensuring that each device is correctly associated. Note: Domain does not scope uniqueness of hardware identifiers. They are still globally unique. Domain helps the clustering algorithm to better determine the right identity by limiting the scope of possibilities. Feedback commands ([i-ecp] Report Hardware Identity Crisis and [i-ecp] Report Hardware Identity Collision) improve detection within the domain."
        },
        "cloningConfiguration": {
          "$ref": "v1CloningConfiguration",
          "description": "Configuration applied to devices cloned from a master device. It defines rules and parameters used during the cloning.",
          "cloneNamingPatterns": [
            {
              "type": "string"
            }
          ],
          "securityGroupUuid": {
            "type": "string",
            "description": "Reference to security group (a device group with is security group set to true), where newly created clones will be added. type: DeviceGroup"
          },
          "securityGroupDisplayName": {
            "type": "string",
            "description": "Display name of the future device group.",
            "readOnly": true
          }
        },
        "operatingSystem": {
          "$ref": "v1OperatingSystem",
          "description": "Descriptor of operating system present on the device.",
          "bitness": {
            "type": "integer",
            "description": "Bitness of the operating system. For example: - 32 - 64",
            "format": "int64"
          },
          "displayName": {
            "type": "string",
            "description": "Human readable name of the operating system. For example: - Mac OS X 10.8 Mountain Lion - Microsoft Windows 10 Enterprise 2015 LTSB"
          },
          "editionId": {
            "type": "integer",
            "description": "Server or Desktop? That's the question. Id comes from [os_catalog]. Well known values are: 0 = unspecified (fallback) 1 = Server edition of operating system, for example, Red Hat Enterprise Linux Server 2 = Client edition of operating system, for example, Windows 11 3 = Mobile edition of operating system, for example, Android or iOS 4 = Core edition without GUI, for example, Microsoft Server Core",
            "format": "int64"
          },
          "familyId": {
            "type": "integer",
            "description": "Family of operating system from [os_catalog]. Info: Modeled after Category: Operating system families. Well known values are: 0 = unspecified (fallback) 1 = Windows family of operating systems 2 = Linux family of operating systems 3 = Apple family of operating systems, for example, OS X or iOS 4 = Android family of operating systems 5 = Windows mobile family 6 = Symbian family 7 = UNIX, including FreeBSD",
            "format": "int64"
          },
          "version": {
            "$ref": "v1Version",
            "description": "Version descriptor. Both values are required to completely reconstruct version information.",
            "id": {
              "type": "string",
              "description": "[Version id] determines whether one version is more recent than another. More recent versions have higher numbers. Can be processed by machine. If human readable version_name meets certain criteria, it can be converted to version_id automatically. The cases are: Windows => VersionId = MajorVersion << 48 | MinorVersion << 32 | ServicePackMajor << 24 | ServicePackMinor << 16 | CurrentBuildNumber Android => VersionId = API level YYYYMMDD => VersionId = (YYYY & 0xffff ) << 48 | (MM & 0xffff) << 32 | (DD & 0xffff) <<16 YYYY.MM => VersionId = (YYYY & 0xffff ) << 48 | (MM & 0xffff) << 32 YY.MM => VersionId = (YY & 0xffff ) << 48 | (MM & 0xffff) << 32 YYYY => VersionId = (YYYY & 0xffff ) << 48 Major.Minor.Patch => VersionId = (Major & 0xffff ) << 48 | (Minor & 0xffff) << 32 | (Patch & 0xffff) <<16 EULA | Terms of Use => VersionId = MajorVersion << 48 | MinorVersion << 32 | Patch << 16 A.B.C.D => VersionId = (A & 0xffff) << 48 | (B & 0xffff) << 32 | (C & 0xffff) << 16 | (D & 0xffff) A.B.C => VersionId = (A & 0xffff ) << 48 | (B & 0xffff) << 32 | (C & 0xffff) <<16 A.B => VersionId = (A & 0xffff ) << 48 | (B & 0xffff) << 32 A => VersionId = (A & 0xffff ) << 48",
              "format": "uint64"
            },
            "major": {
              "type": "integer",
              "description": "Major version if and only if version name adheres to semantic versioning. 0 or null otherwise.",
              "format": "int64",
              "readOnly": true
            },
            "minor": {
              "type": "integer",
              "description": "Minor version if and only if version name adheres to semantic versioning. 0 or null otherwise.",
              "format": "int64",
              "readOnly": true
            },
            "name": {
              "type": "string",
              "description": "Human readable name of the version. E.g. '10.2.3.145'"
            },
            "patch": {
              "type": "integer",
              "description": "Patch if and only if version name adheres to semantic versioning. 0 or null otherwise.",
              "format": "int64",
              "readOnly": true
            }
          }
        },
        "originalDisplayName": {
          "type": "string",
          "description": "The original display name shows the name of the device as it was originally retrieved from the source (for example, operating system). This name is likely used in the device directory (for example, Active Directory), and it is useful in support scenarios. Example: 'BTS9955454' (such a name would likely get renamed by a user to something more friendly).",
          "readOnly": true
        },
        "parentGroupUuid": {
          "type": "string",
          "description": "Reference to the parent [device group] that exclusively contains the device. type: DeviceGroup"
        },
        "primaryLocalIpAddress": {
          "type": "string",
          "description": "Primary IP address of the endpoint retrieved from all available Ethernet interfaces on the device. The process for determining this IP address differs based on the operating system in two steps: Enumeration of all Ethernet interfaces and their associated IP addresses by using: - Android: NetworkInterface.getNetworkInterfaces() method from the Android API. - Apple macOS: IOServiceMatching function provided by the macOS I/O Kit framework. - Linux: getifaddrs() system call. - Microsoft Windows: GetAdaptersInfo() function from the IP Helper API. The Ethernet interfaces and their associated IP addresses are ordered based on the operating system's internal logic. Selection of the primary local IP address from the list of Ethernet interfaces: - among all Ethernet interfaces, IPv4 addresses are prioritized. The first IPv4 address encountered across all Ethernet interfaces is selected as the primary_local_ip_address. - if no Ethernet interface has an IPv4 address, the first available IPv6 address from the list is selected instead. Info: For Apple iOS the primary_local_ip_address is not available. This attribute serves as the primary local IP address that represents the endpoint within its local network."
        },
        "publicIpAddress": {
          "type": "string",
          "description": "The public_IP_address represents the public-facing IP address of the endpoint as resolved and identified by the server communicating with the endpoint. This address reflects the endpoint's presence on the wider internet and is often the IP address assigned by the network's NAT (Network Address Translation) or gateway device. This attribute is used to uniquely identify the endpoint from the perspective of external servers or services, providing the public IP address that is visible outside the local network."
        },
        "tags": [
          {
            "type": "string"
          }
        ],
        "uuid": {
          "type": "string",
          "description": "Unique identifier of the entity. Must be collision-free - two identifiers created anywhere in the world must not collide within the entity parent scope. Unless a member of aggregate, the entity scope is always global. Although most of the times compliant with RFC 4122: A Universally Unique IDentifier (UUID) URN Namespace, do not rely on it being a RFC UUID. Treat it as an opaque identifier. RFC UUID can be recognized by being formatted according to the template xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, as explained on Wikipedia. UUID is used for referencing an entity, even across domains. Example: '123e4567-e89b-12d3-a456-426614174000'"
        },
        "etag": {
          "type": "string",
          "description": "The entity tag (or ETag) can be thought of as a snapshot of a resource’s state at a given revision and can used for optimistic concurrency control and validating entity freshness. It is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding. An entity-tag consists of an opaque quoted string (hash or checksum), possibly prefixed by a weakness indicator as specified in RFC2616, Section 13.3.3 eTag value must follow RFC7232, Section 2.3 and google's specification. Info: eTag can be used as a complementary to mechanism to revisioning, where: - Revisions for tracking history and allowing access to previous versions google's AIP 162 - ETags for concurrency control and validating freshness google's AIP 154 The same resource may expose revision_id that clients can list or roll back to past snapshots and also eTag, which - serve as a practical implementation of revisions for managing resource versions in real-time operations. - ensure that clients operate on the expected version of a resource, preventing conflicts in concurrent scenarios (e.g., two clients trying to update the same resource simultaneously). In contrast to revisions ETags don’t provide a full revision history (like a version control system). However, they enable safe updates and deletes by tying each operation to a specific resource state—effectively a revision.",
          "readOnly": true
        },
        "ownerUuid": {
          "type": "string",
          "description": "Identifier of the tenant who owns this object. type: tenant_management.v1.Tenant"
        }
      }
    }
default | An unexpected error response. Response example
    {
      "code": 0,
      "message": "string",
      "details": [
        {
          "@type": "string",
          "additionalProp1": {},
          "additionalProp2": {},
          "additionalProp3": {}
        }
      ]
    }
| An unexpected error response. Response schema
    {
      "$ref": "rpcStatus",
      "description": "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. 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.",
      "code": {
        "type": "integer",
        "description": "The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].",
        "format": "int32"
      },
      "message": {
        "type": "string",
        "description": "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][google.rpc.Status.details] field, or localized by the client."
      },
      "details": [
        {
          "$ref": "protobufAny",
          "description": "Any contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example 'foo.bar.com/x/y.z' will yield type name 'y.z'. JSON The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { '@type': 'type.googleapis.com/google.profile.Person', 'firstName': <string>, 'lastName': <string> } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field value which holds the custom JSON in addition to the @type field. Example (for message [google.protobuf.Duration][]): { '@type': 'type.googleapis.com/google.protobuf.Duration', 'value': '1.212s' }",
          "@type": {
            "type": "string",
            "description": "A URL/resource name whose content describes the type of the serialized protocol buffer message. For URLs which use the scheme http, https, or no scheme, the following restrictions and interpretations apply: If no scheme is provided, https is assumed. The last segment of the URL's path must represent the fully qualified name of the type (as in path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading '.' is not accepted). An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics."
          },
          "additionalProperties": {
            "type": "object"
          }
        }
      ]
    }

˄˅