Win32_ComputerSystem

If $true, the automatic reset is enabled.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, AutomaticResetCapability

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty AutomaticResetCapability
"AutomaticResetCapability = $value"

BootOptionOnLimit

Identifies the system action when the ResetLimit value is reached. This is a feature managed by the system bios. WMI just exposes the current BIOS setting but won’t allow changes.

BootOptionOnLimit returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName BootOptionOnLimit -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumBootOptionOnLimit
  {
    Reserved          = 0
    OperatingSystem   = 1
    SystemUtilities   = 2
    DoNotReboot       = 3
  }

  [EnumBootOptionOnLimit]($this.PSBase.CimInstanceProperties['BootOptionOnLimit'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootOptionOnLimit

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$BootOptionOnLimit = @{
  Name = 'BootOptionOnLimitText'
  Expression = {
    $value = $_.BootOptionOnLimit
    
    switch([int]$value)
      {
        0          {'Reserved'}
        1          {'OperatingSystem'}
        2          {'SystemUtilities'}
        3          {'DoNotReboot'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootOptionOnLimit, $BootOptionOnLimit

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$BootOptionOnLimit_map = @{
      0 = 'Reserved'
      1 = 'OperatingSystem'
      2 = 'SystemUtilities'
      3 = 'DoNotReboot'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumBootOptionOnLimit
{
  Reserved          = 0
  OperatingSystem   = 1
  SystemUtilities   = 2
  DoNotReboot       = 3
}

BootOptionOnWatchDog

Type of reboot action after the time on the watchdog timer is elapsed.

BootOptionOnWatchDog returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName BootOptionOnWatchDog -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumBootOptionOnWatchDog
  {
    Reserved          = 0
    OperatingSystem   = 1
    SystemUtilities   = 2
    DoNotReboot       = 3
  }

  [EnumBootOptionOnWatchDog]($this.PSBase.CimInstanceProperties['BootOptionOnWatchDog'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootOptionOnWatchDog

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$BootOptionOnWatchDog = @{
  Name = 'BootOptionOnWatchDogText'
  Expression = {
    $value = $_.BootOptionOnWatchDog
    
    switch([int]$value)
      {
        0          {'Reserved'}
        1          {'OperatingSystem'}
        2          {'SystemUtilities'}
        3          {'DoNotReboot'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootOptionOnWatchDog, $BootOptionOnWatchDog

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$BootOptionOnWatchDog_map = @{
      0 = 'Reserved'
      1 = 'OperatingSystem'
      2 = 'SystemUtilities'
      3 = 'DoNotReboot'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumBootOptionOnWatchDog
{
  Reserved          = 0
  OperatingSystem   = 1
  SystemUtilities   = 2
  DoNotReboot       = 3
}

BootROMSupported

If $true, indicates whether a boot ROM is supported.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootROMSupported

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty BootROMSupported
"BootROMSupported = $value"

BootStatus

UINT16 ARRAY

Status and Additional Data fields that identify the boot status.

This value comes from the Boot Status member of the System Boot Information structure in the SMBIOS information.

This property is not supported before Windows 10 and Windows Server 2016.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootStatus

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty BootStatus
"BootStatus = $value"

BootupState

System is started. Fail-safe boot bypasses the user startup files also called SafeBoot.

Available values:

'Normal boot'', ''Fail-safe boot'', ''Fail-safe with network boot''

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, BootupState

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty BootupState
"BootupState = $value"

Caption

STRING MAX 64 CHAR

Short description of the object a one-line string.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Caption

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Caption
"Caption = $value"

ChassisBootupState

Boot up state of the chassis.

This value comes from the Boot-up State member of the System Enclosure or Chassis structure in the SMBIOS information.

ChassisBootupState returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName ChassisBootupState -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumChassisBootupState
  {
    Other             = 1
    Unknown           = 2
    Safe              = 3
    Warning           = 4
    Critical          = 5
    Non_recoverable   = 6
  }

  [EnumChassisBootupState]($this.PSBase.CimInstanceProperties['ChassisBootupState'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ChassisBootupState

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$ChassisBootupState = @{
  Name = 'ChassisBootupStateText'
  Expression = {
    $value = $_.ChassisBootupState
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Safe'}
        4          {'Warning'}
        5          {'Critical'}
        6          {'Non-recoverable'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ChassisBootupState, $ChassisBootupState

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$ChassisBootupState_map = @{
= 'Other'
= 'Unknown'
= 'Safe'
= 'Warning'
= 'Critical'
= 'Non-recoverable'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumChassisBootupState
{
  Other             = 1
  Unknown           = 2
  Safe              = 3
  Warning           = 4
  Critical          = 5
  Non_recoverable   = 6
}

ChassisSKUNumber

The chassis or enclosure SKU number as a string.

This value comes from the SKU Number member of the System Enclosure or Chassis structure in the SMBIOS information.

This property is not supported before Windows 10 and Windows Server 2016.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ChassisSKUNumber

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty ChassisSKUNumber
"ChassisSKUNumber = $value"

CreationClassName

WRITEABLE INT16 “MINUTES”

Name of the first concrete class in the inheritance chain of an instance. You can use this property with other properties of the class to identify all instances of the class and its subclasses.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, CreationClassName

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty CreationClassName
"CreationClassName = $value"

CurrentTimeZone

Amount of time the unitary computer system is offset from Coordinated Universal Time (UTC).

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, CurrentTimeZone

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty CurrentTimeZone
"CurrentTimeZone = ${value} minutes"

DaylightInEffect

If $true, the daylight savings mode is ON.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, DaylightInEffect

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty DaylightInEffect
"DaylightInEffect = $value"

Description

Description of the object.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Description

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Description
"Description = $value"

DNSHostName

Name of local computer according to the domain name server (DNS).

This information is produced by the Windows API method GetComputerNameEx().

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, DNSHostName

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty DNSHostName
"DNSHostName = $value"

Domain

Name of the domain to which a computer belongs.

If the computer is not part of a domain, then the name of the workgroup is returned.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Domain

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Domain
"Domain = $value"

DomainRole

Role of a computer in an Active Directory environment. Domain controllers render important infrastructure services and are especially security-critical.

DomainRole returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName DomainRole -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumDomainRole
  {
    Standalone_Workstation_     = 0
    Member_Workstation          = 1
    Standalone_Server           = 2
    Member_Server_              = 3
    Backup_Domain_Controller_   = 4
    Primary_Domain_Controller   = 5
  }

  [EnumDomainRole]($this.PSBase.CimInstanceProperties['DomainRole'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, DomainRole

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$DomainRole = @{
  Name = 'DomainRoleText'
  Expression = {
    $value = $_.DomainRole
    
    switch([int]$value)
      {
        0          {'Standalone_Workstation   '}
        1          {'Member_Workstation'}
        2          {'Standalone_Server'}
        3          {'Member_Server            '}
        4          {'Backup_Domain_Controller '}
        5          {'Primary_Domain_Controller'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, DomainRole, $DomainRole

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$DomainRole_map = @{
= 'Standalone_Workstation   '
= 'Member_Workstation'
= 'Standalone_Server'
= 'Member_Server            '
= 'Backup_Domain_Controller '
= 'Primary_Domain_Controller'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumDomainRole
{
  Standalone_Workstation_     = 0
  Member_Workstation          = 1
  Standalone_Server           = 2
  Member_Server_              = 3
  Backup_Domain_Controller_   = 4
  Primary_Domain_Controller   = 5
}

EnableDaylightSavingsTime

WRITEABLE BOOL

Enables daylight savings time (DST) on a computer. A value of $true indicates that the system time changes to an hour ahead or behind when DST starts or ends. A value of $false indicates that the system time does not change to an hour ahead or behind when DST starts or ends. A value of NULL indicates that the DST status is unknown on a system.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, EnableDaylightSavingsTime

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty EnableDaylightSavingsTime
"EnableDaylightSavingsTime = $value"

FrontPanelResetStatus

The following table lists the hardware security settings for the reset button on a computer.

FrontPanelResetStatus returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName FrontPanelResetStatus -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumFrontPanelResetStatus
  {
    Disabled          = 0
    Enabled           = 1
    Not_Implemented   = 2
    Unknown           = 3
  }

  [EnumFrontPanelResetStatus]($this.PSBase.CimInstanceProperties['FrontPanelResetStatus'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, FrontPanelResetStatus

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$FrontPanelResetStatus = @{
  Name = 'FrontPanelResetStatusText'
  Expression = {
    $value = $_.FrontPanelResetStatus
    
    switch([int]$value)
      {
        0          {'Disabled'}
        1          {'Enabled'}
        2          {'Not_Implemented'}
        3          {'Unknown'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, FrontPanelResetStatus, $FrontPanelResetStatus

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$FrontPanelResetStatus_map = @{
      0 = 'Disabled'
      1 = 'Enabled'
      2 = 'Not_Implemented'
      3 = 'Unknown'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumFrontPanelResetStatus
{
  Disabled          = 0
  Enabled           = 1
  Not_Implemented   = 2
  Unknown           = 3
}

HypervisorPresent

If $true, a hypervisor is present.

This property is not supported before Windows 8 and Windows Server 2012.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, HypervisorPresent

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty HypervisorPresent
"HypervisorPresent = $value"

InfraredSupported

If $true, an infrared (IR) port exists on a computer system.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, InfraredSupported

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty InfraredSupported
"InfraredSupported = $value"

InitialLoadInfo

STRING ARRAY

Data required to find the initial load device or boot service to request that the operating system start up.

This property is typically empty.

InstallDate

DATETIME

This property is inherited and typically empty.

KeyboardPasswordStatus

System hardware security settings for Keyboard Password Status.

KeyboardPasswordStatus returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName KeyboardPasswordStatus -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumKeyboardPasswordStatus
  {
    Disabled          = 0
    Enabled           = 1
    Not_Implemented   = 2
    Unknown           = 3
  }

  [EnumKeyboardPasswordStatus]($this.PSBase.CimInstanceProperties['KeyboardPasswordStatus'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, KeyboardPasswordStatus

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$KeyboardPasswordStatus = @{
  Name = 'KeyboardPasswordStatusText'
  Expression = {
    $value = $_.KeyboardPasswordStatus
    
    switch([int]$value)
      {
        0          {'Disabled'}
        1          {'Enabled'}
        2          {'Not_Implemented'}
        3          {'Unknown'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, KeyboardPasswordStatus, $KeyboardPasswordStatus

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$KeyboardPasswordStatus_map = @{
      0 = 'Disabled'
      1 = 'Enabled'
      2 = 'Not_Implemented'
      3 = 'Unknown'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumKeyboardPasswordStatus
{
  Disabled          = 0
  Enabled           = 1
  Not_Implemented   = 2
  Unknown           = 3
}

LastLoadInfo

Array entry of the InitialLoadInfo property that contains the data to start the loaded operating system.

This property is typically empty.

Manufacturer

Name of a computer manufacturer.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Manufacturer

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Manufacturer
"Manufacturer = $value"

Model

Product name that a manufacturer gives to a computer. This property must have a value.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Model

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Model
"Model = $value"

Name

KEY PROPERTY STRING

Name of system. This is the key property.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Name
"Name = $value"

NameFormat

Computer system Name value that is generated automatically. The CIM_ComputerSystem object and its derivatives are top-level objects of the Common Information Model (CIM). They provide the scope for several components. Unique CIM_System keys are required, but you can define a heuristic to create the CIM_ComputerSystem name that generates the same name, and is independent from the discovery protocol. This prevents inventory and management problems when the same asset or entity is discovered multiple times, but cannot be resolved to one object. Using a heuristic is recommended, but not required.

The heuristic is outlined in the CIM V2 Common Model specification, and assumes that the documented rules are used to determine and assign a name. The NameFormat values list defines the order to assign a computer system name. Several rules map to the same value.

The CIM_ComputerSystem Name value that is calculated using the heuristic is the key value of the system. However, use aliases to assign a different name for CIM_ComputerSystem, which can be more unique to your company.Available values:

'IP', 'Dial', 'HID', 'NWA', 'HWA', 'X25', 'ISDN', 'IPX', 'DCC', 'ICD', 'E164', 'SNA', 'OID_OSI', 'Other'

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, NameFormat

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty NameFormat
"NameFormat = $value"

NetworkServerModeEnabled

If $true, the network Server Mode is enabled.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, NetworkServerModeEnabled

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty NetworkServerModeEnabled
"NetworkServerModeEnabled = $value"

NumberOfLogicalProcessors

UINT32

Number of logical processors available on the computer.

You can use NumberOfLogicalProcessors and NumberOfProcessors to determine if the computer is hyperthreading. For more information, see Remarks.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, NumberOfLogicalProcessors

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty NumberOfLogicalProcessors
"NumberOfLogicalProcessors = $value"

NumberOfProcessors

UINT32

Number of physical processors currently available on a system. This is the number of enabled processors for a system, which does not include the disabled processors. If a computer system has two physical processors each containing two logical processors, then the value of NumberOfProcessors is 2 and NumberOfLogicalProcessors is 4. The processors may be multicore or they may be hyperthreading processors. For more information, see Remarks.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, NumberOfProcessors

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty NumberOfProcessors
"NumberOfProcessors = $value"

OEMLogoBitmap

BYTE ARRAY

List of data for a bitmap that the original equipment manufacturer (OEM) creates.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, OEMLogoBitmap

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty OEMLogoBitmap
"OEMLogoBitmap = $value"

OEMStringArray

STRING ARRAY

List of free-form strings that an OEM defines. For example, an OEM defines the part numbers for system reference documents, manufacturer contact information, and so on.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, OEMStringArray

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty OEMStringArray
"OEMStringArray = $value"

PartOfDomain

If $true, the computer is part of a domain. If the value is NULL, the computer is not in a domain or the status is unknown. If you remove the computer from a domain, the value becomes false.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PartOfDomain

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty PartOfDomain
"PartOfDomain = $value"

PauseAfterReset

INT64 “MILLISECONDS”

Time delay before a reboot is initiated in milliseconds. It is used after a system power cycle, local or remote system reset, and automatic system reset. A value of 1 (minus one) indicates that the pause value is unknown.

Windows Vista: This property may return an unknown number.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PauseAfterReset

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty PauseAfterReset
"PauseAfterReset = ${value} milliseconds"

PCSystemType

Type of the computer in use, such as laptop, desktop, or Tablet.

PCSystemType returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName PCSystemType -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumPCSystemType
  {
    Unspecified          = 0
    Desktop              = 1
    Mobile               = 2
    Workstation          = 3
    Enterprise_Server    = 4
    SOHO_Server          = 5
    Appliance_PC         = 6
    Performance_Server   = 7
    Maximum              = 8
  }

  [EnumPCSystemType]($this.PSBase.CimInstanceProperties['PCSystemType'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PCSystemType

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$PCSystemType = @{
  Name = 'PCSystemTypeText'
  Expression = {
    $value = $_.PCSystemType
    
    switch([int]$value)
      {
        0          {'Unspecified'}
        1          {'Desktop'}
        2          {'Mobile'}
        3          {'Workstation'}
        4          {'Enterprise Server'}
        5          {'SOHO Server'}
        6          {'Appliance PC'}
        7          {'Performance Server'}
        8          {'Maximum'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PCSystemType, $PCSystemType

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$PCSystemType_map = @{
= 'Unspecified'
= 'Desktop'
= 'Mobile'
= 'Workstation'
= 'Enterprise Server'
= 'SOHO Server'
= 'Appliance PC'
= 'Performance Server'
= 'Maximum'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumPCSystemType
{
  Unspecified          = 0
  Desktop              = 1
  Mobile               = 2
  Workstation          = 3
  Enterprise_Server    = 4
  SOHO_Server          = 5
  Appliance_PC         = 6
  Performance_Server   = 7
  Maximum              = 8
}

PCSystemTypeEx

Type of the computer in use, such as laptop, desktop, or Tablet.

This property is not supported before Windows 8.1 and Windows Server 2012 R2.

PCSystemTypeEx returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName PCSystemTypeEx -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumPCSystemTypeEx
  {
    Unspecified          = 0
    Desktop              = 1
    Mobile               = 2
    Workstation          = 3
    Enterprise_Server    = 4
    SOHO_Server          = 5
    Appliance_PC         = 6
    Performance_Server   = 7
    Slate                = 8
    Maximum              = 9
  }

  [EnumPCSystemTypeEx]($this.PSBase.CimInstanceProperties['PCSystemTypeEx'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PCSystemTypeEx

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$PCSystemTypeEx = @{
  Name = 'PCSystemTypeExText'
  Expression = {
    $value = $_.PCSystemTypeEx
    
    switch([int]$value)
      {
        0          {'Unspecified'}
        1          {'Desktop'}
        2          {'Mobile'}
        3          {'Workstation'}
        4          {'Enterprise Server'}
        5          {'SOHO Server'}
        6          {'Appliance PC'}
        7          {'Performance Server'}
        8          {'Slate'}
        9          {'Maximum'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PCSystemTypeEx, $PCSystemTypeEx

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$PCSystemTypeEx_map = @{
= 'Unspecified'
= 'Desktop'
= 'Mobile'
= 'Workstation'
= 'Enterprise Server'
= 'SOHO Server'
= 'Appliance PC'
= 'Performance Server'
= 'Slate'
= 'Maximum'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumPCSystemTypeEx
{
  Unspecified          = 0
  Desktop              = 1
  Mobile               = 2
  Workstation          = 3
  Enterprise_Server    = 4
  SOHO_Server          = 5
  Appliance_PC         = 6
  Performance_Server   = 7
  Slate                = 8
  Maximum              = 9
}

PowerManagementCapabilities

UINT16 ARRAY

Array of the specific power-related capabilities of a logical device. This property is inherited and typically empty.

PowerManagementSupported

If $true, device can be power-managed, for example, a device can be put into suspend mode, and so on. This property does not indicate that power management features are enabled currently, but it does indicate that the logical device is capable of power management. For this class instances, the property is typically empty.

PowerOnPasswordStatus

System hardware security settings for Power-On Password Status.

PowerOnPasswordStatus returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName PowerOnPasswordStatus -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumPowerOnPasswordStatus
  {
    Disabled          = 0
    Enabled           = 1
    Not_implemented   = 2
    Unknown           = 3
  }

  [EnumPowerOnPasswordStatus]($this.PSBase.CimInstanceProperties['PowerOnPasswordStatus'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerOnPasswordStatus

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$PowerOnPasswordStatus = @{
  Name = 'PowerOnPasswordStatusText'
  Expression = {
    $value = $_.PowerOnPasswordStatus
    
    switch([int]$value)
      {
        0          {'Disabled'}
        1          {'Enabled'}
        2          {'Not implemented'}
        3          {'Unknown'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerOnPasswordStatus, $PowerOnPasswordStatus

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$PowerOnPasswordStatus_map = @{
      0 = 'Disabled'
      1 = 'Enabled'
      2 = 'Not implemented'
      3 = 'Unknown'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumPowerOnPasswordStatus
{
  Disabled          = 0
  Enabled           = 1
  Not_implemented   = 2
  Unknown           = 3
}

PowerState

Current power state of a computer and its associated operating system. The power saving states have the following values: Value 4 (Unknown) indicates that the system is known to be in a power save mode, but its exact status in this mode is unknown; 2 (Low Power Mode) indicates that the system is in a power save state, but still functioning and may exhibit degraded performance; 3 (Standby) indicates that the system is not functioning, but could be brought to full power quickly; and 7 (Warning) indicates that the computer system is in a warning state and a power save mode.

PowerState returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName PowerState -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumPowerState
  {
    Unknown                     = 0
    Full_Power                  = 1
    Power_Save_Low_Power_Mode   = 2
    Power_Save_Standby          = 3
    Power_Save_Unknown          = 4
    Power_Cycle                 = 5
    Power_Off                   = 6
    Power_Save_Warning          = 7
    Power_Save_Hibernate        = 8
    Power_Save_Soft_Off         = 9
  }

  [EnumPowerState]($this.PSBase.CimInstanceProperties['PowerState'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerState

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$PowerState = @{
  Name = 'PowerStateText'
  Expression = {
    $value = $_.PowerState
    
    switch([int]$value)
      {
        0          {'Unknown'}
        1          {'Full Power'}
        2          {'Power Save - Low Power Mode'}
        3          {'Power Save - Standby'}
        4          {'Power Save - Unknown'}
        5          {'Power Cycle'}
        6          {'Power Off'}
        7          {'Power Save - Warning'}
        8          {'Power Save - Hibernate'}
        9          {'Power Save - Soft Off'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerState, $PowerState

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$PowerState_map = @{
= 'Unknown'
= 'Full Power'
= 'Power Save - Low Power Mode'
= 'Power Save - Standby'
= 'Power Save - Unknown'
= 'Power Cycle'
= 'Power Off'
= 'Power Save - Warning'
= 'Power Save - Hibernate'
= 'Power Save - Soft Off'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumPowerState
{
  Unknown                     = 0
  Full_Power                  = 1
  Power_Save_Low_Power_Mode   = 2
  Power_Save_Standby          = 3
  Power_Save_Unknown          = 4
  Power_Cycle                 = 5
  Power_Off                   = 6
  Power_Save_Warning          = 7
  Power_Save_Hibernate        = 8
  Power_Save_Soft_Off         = 9
}

PowerSupplyState

State of the power supply or supplies when last booted.

This value comes from the Power Supply State member of the System Enclosure or Chassis structure in the SMBIOS information.

The following list identifies the values for this property.

PowerSupplyState returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName PowerSupplyState -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumPowerSupplyState
  {
    Other             = 1
    Unknown           = 2
    Safe              = 3
    Warning           = 4
    Critical          = 5
    Non_recoverable   = 6
  }

  [EnumPowerSupplyState]($this.PSBase.CimInstanceProperties['PowerSupplyState'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerSupplyState

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$PowerSupplyState = @{
  Name = 'PowerSupplyStateText'
  Expression = {
    $value = $_.PowerSupplyState
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Safe'}
        4          {'Warning'}
        5          {'Critical'}
        6          {'Non-recoverable'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PowerSupplyState, $PowerSupplyState

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$PowerSupplyState_map = @{
= 'Other'
= 'Unknown'
= 'Safe'
= 'Warning'
= 'Critical'
= 'Non-recoverable'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumPowerSupplyState
{
  Other             = 1
  Unknown           = 2
  Safe              = 3
  Warning           = 4
  Critical          = 5
  Non_recoverable   = 6
}

PrimaryOwnerContact

Contact information for the primary system owner, for example, phone number, email address, and so on.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PrimaryOwnerContact

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty PrimaryOwnerContact
"PrimaryOwnerContact = $value"

PrimaryOwnerName

STRING MAX 64 CHAR

Name of the primary system owner.

This value is stored in the Windows Registry in value RegisteredOwner in the key *HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion*.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, PrimaryOwnerName

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty PrimaryOwnerName
"PrimaryOwnerName = $value"

ResetCapability

If enabled, the value is 4 and the unitary computer system can be reset using the power and reset buttons. If disabled, the value is 3, and a reset is not allowed.

ResetCapability returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName ResetCapability -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumResetCapability
  {
    Other             = 1
    Unknown           = 2
    Disabled          = 3
    Enabled           = 4
    Not_Implemented   = 5
  }

  [EnumResetCapability]($this.PSBase.CimInstanceProperties['ResetCapability'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ResetCapability

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$ResetCapability = @{
  Name = 'ResetCapabilityText'
  Expression = {
    $value = $_.ResetCapability
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Disabled'}
        4          {'Enabled'}
        5          {'Not Implemented'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ResetCapability, $ResetCapability

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$ResetCapability_map = @{
= 'Other'
= 'Unknown'
= 'Disabled'
= 'Enabled'
= 'Not Implemented'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumResetCapability
{
  Other             = 1
  Unknown           = 2
  Disabled          = 3
  Enabled           = 4
  Not_Implemented   = 5
}

ResetCount

INT16

Number of automatic resets since the last reset. A value of -1 indicates that the count is unknown.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ResetCount

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty ResetCount
"ResetCount = $value"

ResetLimit

INT16

Number of consecutive times a system reset is attempted. A value of -1 indicates that the limit is unknown.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ResetLimit

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty ResetLimit
"ResetLimit = $value"

Roles

WRITEABLE STRING ARRAY

String array that specifies the roles of a system in the IT environment.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Roles

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Roles
"Roles = $value"

Status

STRING MAX 10 CHAR

Current status of an object. Various operational and nonoperational statuses can be defined.

Available values:

'Degraded','Error','Lost Comm','No Contact','NonRecover','OK','Pred Fail','Service','Starting','Stopping','Stressed','Unknown'

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, Status

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty Status
"Status = $value"

SupportContactDescription

STRING ARRAY

List of the support contact information for the Windows operating system.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, SupportContactDescription

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty SupportContactDescription
"SupportContactDescription = $value"

SystemFamily

The family to which a particular computer belongs. A family refers to a set of computers that are similar but not identical from a hardware or software point of view.

This value comes from the Family member of the System Information structure in the SMBIOS information.

This property is not supported before Windows 10 and Windows Server 2016.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, SystemFamily

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty SystemFamily
"SystemFamily = $value"

SystemSKUNumber

WRITEABLE UINT16 “SECONDS”

Identifies a particular computer configuration for sale. It is sometimes also called a product ID or purchase order number.

This value comes from the SKU Number member of the System Information structure in the SMBIOS information.

This property is not supported before Windows 10 and Windows Server 2016.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, SystemSKUNumber

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty SystemSKUNumber
"SystemSKUNumber = $value"

SystemStartupDelay

SystemStartupDelay is no longer available for use because Boot.ini is not used to configure system startup. Instead, use the BCD classes supplied by the Boot Configuration Data (BCD) WMI provider or the Bcdedit command.

SystemStartupOptions

WRITEABLE STRING ARRAY

SystemStartupOptions is no longer available for use because Boot.ini is not used to configure system startup. Instead, use the BCD classes supplied by the Boot Configuration Data (BCD) WMI provider or the Bcdedit command.

SystemStartupSetting

WRITEABLE BYTE

SystemStartupSetting is no longer available for use because Boot.ini is not used to configure system startup. Instead, use the BCD classes supplied by the Boot Configuration Data (BCD) WMI provider or the Bcdedit command.

SystemType

System running on the Windows-based computer. This property must have a value.

The following list identifies some of the possible values for this property.

X86-based PC (“X86-based PC”)

MIPS-based PC (“MIPS-based PC”)

Alpha-based PC (“Alpha-based PC”)

Power PC (“Power PC”)

SH-x PC (“SH-x PC”)

StrongARM PC (“StrongARM PC”)

64-bit Intel PC (“64-bit Intel PC”)

x64-based PC (“x64-based PC”)

Unknown (“Unknown”)

X86-Nec98 PC (“X86-Nec98 PC”)

Available values:

'64-bit Intel PC'', ''Alpha-based PC'', ''MIPS-based PC'', ''Power PC'', ''SH-x PC'', ''StrongARM PC'', ''x64-based PC'', ''X86-based PC'', ''X86-Nec98 PC'', ''Unknown''

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, SystemType

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty SystemType
"SystemType = $value"

ThermalState

Thermal state of the system when last booted.

This value comes from the Thermal State member of the System Enclosure or Chassis structure in the SMBIOS information.

ThermalState returns a numeric value. To translate it into a meaningful text, use any of the following approaches:

Use Update-Type

Update-Type tells PowerShell how to interpret the property. This command needs to be executed only once per PowerShell session:

Update-TypeData -MemberName ThermalState -TypeName "Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem" -MemberType ScriptProperty  -Value {
  Enum EnumThermalState
  {
    Other             = 1
    Unknown           = 2
    Safe              = 3
    Warning           = 4
    Critical          = 5
    Non_recoverable   = 6
  }

  [EnumThermalState]($this.PSBase.CimInstanceProperties['ThermalState'].Value)
} -Force

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ThermalState

Use Select-Object

Select-Object supports calculated properties. When you submit a hashtable, PowerShell dynamically calculates the result:

$ThermalState = @{
  Name = 'ThermalStateText'
  Expression = {
    $value = $_.ThermalState
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Safe'}
        4          {'Warning'}
        5          {'Critical'}
        6          {'Non-recoverable'}
        default    {"$value"}
      }
      
  }  
}

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, ThermalState, $ThermalState

Use a PowerShell Hashtable

You can use a PowerShell hashtable to decode numeric values. Use a hashtable like this one:

$ThermalState_map = @{
= 'Other'
= 'Unknown'
= 'Safe'
= 'Warning'
= 'Critical'
= 'Non-recoverable'
}

Use Enum structure

You can cast the raw property values to a new enum type to translate raw numeric values into friendly text. Use an enum like this one:

Enum EnumThermalState
{
  Other             = 1
  Unknown           = 2
  Safe              = 3
  Warning           = 4
  Critical          = 5
  Non_recoverable   = 6
}

TotalPhysicalMemory

UINT64 “BYTES”

Total size of physical memory. Be aware that, under some circumstances, this property may not return an accurate value for the physical memory. For example, it is not accurate if the BIOS is using some of the physical memory. For an accurate value, use the Capacity property in Win32_PhysicalMemory instead.

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, TotalPhysicalMemory

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty TotalPhysicalMemory
"TotalPhysicalMemory = ${value} bytes"
'TotalPhysicalMemory = {0:n1} GB' -f ($value/1GB)

You can update the PowerShell type database to automatically convert the raw property value. This example illustrates overwriting ToString() method to provide formatted output while leaving the original property value untouched:

# outputting raw value:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty TotalPhysicalMemory

# updating type database (needs to be done only once per PowerShell session)
# this command instructs PowerShell to overwrite the method ToString() and automatically divide the raw value and transform it in a different unit:
Update-TypeData -MemberName TotalPhysicalMemory -TypeName 'Microsoft.Management.Infrastructure.CimInstance#root/cimv2/win32_computersystem' -MemberType ScriptProperty -Value { ($this.PSBase.CimInstanceProperties['TotalPhysicalMemory'].Value) | Add-Member -MemberType ScriptMethod -Name ToString -Force -Value { "{0:n1} GB" -f ($this/1GB) } -PassThru } -Force

# compare the results of the identical command.
# raw values are now automatically transformed into a more meaningful unit:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty TotalPhysicalMemory

UserName

Name of a user that is logged on currently. This property must have a value. In a terminal services session, UserName returns the name of the user that is logged on to the console not the user logged on during the terminal service session.

Example: jeffsmith

# returning class instances:
Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -Property Name, UserName

# reading property value:
$value = Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object -ExpandProperty UserName
"UserName = $value"

WakeUpType