PSS_HANDLE_ENTRY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PSS_HANDLE_ENTRY
{
    public IntPtr Handle;
    public int Flags;
    public int ObjectType;
    public FILETIME CaptureTime;
    public uint Attributes;
    public uint GrantedAccess;
    public uint HandleCount;
    public uint PointerCount;
    public uint PagedPoolCharge;
    public uint NonPagedPoolCharge;
    public FILETIME CreationTime;
    public ushort TypeNameLength;
    public IntPtr TypeName;
    public ushort ObjectNameLength;
    public IntPtr ObjectName;
    public _TypeSpecificInformation_e__Union TypeSpecificInformation;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PSS_HANDLE_ENTRY
    Public Handle As IntPtr
    Public Flags As Integer
    Public ObjectType As Integer
    Public CaptureTime As FILETIME
    Public Attributes As UInteger
    Public GrantedAccess As UInteger
    Public HandleCount As UInteger
    Public PointerCount As UInteger
    Public PagedPoolCharge As UInteger
    Public NonPagedPoolCharge As UInteger
    Public CreationTime As FILETIME
    Public TypeNameLength As UShort
    Public TypeName As IntPtr
    Public ObjectNameLength As UShort
    Public ObjectName As IntPtr
    Public TypeSpecificInformation As _TypeSpecificInformation_e__Union
End Structure

import ctypes
from ctypes import wintypes

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class PSS_HANDLE_ENTRY(ctypes.Structure):
    _fields_ = [
        ("Handle", ctypes.c_void_p),
        ("Flags", ctypes.c_int),
        ("ObjectType", ctypes.c_int),
        ("CaptureTime", FILETIME),
        ("Attributes", wintypes.DWORD),
        ("GrantedAccess", wintypes.DWORD),
        ("HandleCount", wintypes.DWORD),
        ("PointerCount", wintypes.DWORD),
        ("PagedPoolCharge", wintypes.DWORD),
        ("NonPagedPoolCharge", wintypes.DWORD),
        ("CreationTime", FILETIME),
        ("TypeNameLength", ctypes.c_ushort),
        ("TypeName", ctypes.c_void_p),
        ("ObjectNameLength", ctypes.c_ushort),
        ("ObjectName", ctypes.c_void_p),
        ("TypeSpecificInformation", _TypeSpecificInformation_e__Union),
    ]

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct PSS_HANDLE_ENTRY {
    pub Handle: *mut core::ffi::c_void,
    pub Flags: i32,
    pub ObjectType: i32,
    pub CaptureTime: FILETIME,
    pub Attributes: u32,
    pub GrantedAccess: u32,
    pub HandleCount: u32,
    pub PointerCount: u32,
    pub PagedPoolCharge: u32,
    pub NonPagedPoolCharge: u32,
    pub CreationTime: FILETIME,
    pub TypeNameLength: u16,
    pub TypeName: *mut core::ffi::c_void,
    pub ObjectNameLength: u16,
    pub ObjectName: *mut core::ffi::c_void,
    pub TypeSpecificInformation: _TypeSpecificInformation_e__Union,
}

import "golang.org/x/sys/windows"

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type PSS_HANDLE_ENTRY struct {
	Handle uintptr
	Flags int32
	ObjectType int32
	CaptureTime FILETIME
	Attributes uint32
	GrantedAccess uint32
	HandleCount uint32
	PointerCount uint32
	PagedPoolCharge uint32
	NonPagedPoolCharge uint32
	CreationTime FILETIME
	TypeNameLength uint16
	TypeName uintptr
	ObjectNameLength uint16
	ObjectName uintptr
	TypeSpecificInformation _TypeSpecificInformation_e__Union
}

type
  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  PSS_HANDLE_ENTRY = record
    Handle: Pointer;
    Flags: Integer;
    ObjectType: Integer;
    CaptureTime: FILETIME;
    Attributes: DWORD;
    GrantedAccess: DWORD;
    HandleCount: DWORD;
    PointerCount: DWORD;
    PagedPoolCharge: DWORD;
    NonPagedPoolCharge: DWORD;
    CreationTime: FILETIME;
    TypeNameLength: Word;
    TypeName: Pointer;
    ObjectNameLength: Word;
    ObjectName: Pointer;
    TypeSpecificInformation: _TypeSpecificInformation_e__Union;
  end;

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const PSS_HANDLE_ENTRY = extern struct {
    Handle: ?*anyopaque,
    Flags: i32,
    ObjectType: i32,
    CaptureTime: FILETIME,
    Attributes: u32,
    GrantedAccess: u32,
    HandleCount: u32,
    PointerCount: u32,
    PagedPoolCharge: u32,
    NonPagedPoolCharge: u32,
    CreationTime: FILETIME,
    TypeNameLength: u16,
    TypeName: ?*anyopaque,
    ObjectNameLength: u16,
    ObjectName: ?*anyopaque,
    TypeSpecificInformation: _TypeSpecificInformation_e__Union,
};

type
  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  PSS_HANDLE_ENTRY {.bycopy.} = object
    Handle: pointer
    Flags: int32
    ObjectType: int32
    CaptureTime: FILETIME
    Attributes: uint32
    GrantedAccess: uint32
    HandleCount: uint32
    PointerCount: uint32
    PagedPoolCharge: uint32
    NonPagedPoolCharge: uint32
    CreationTime: FILETIME
    TypeNameLength: uint16
    TypeName: pointer
    ObjectNameLength: uint16
    ObjectName: pointer
    TypeSpecificInformation: _TypeSpecificInformation_e__Union

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct PSS_HANDLE_ENTRY
{
    void* Handle;
    int Flags;
    int ObjectType;
    FILETIME CaptureTime;
    uint Attributes;
    uint GrantedAccess;
    uint HandleCount;
    uint PointerCount;
    uint PagedPoolCharge;
    uint NonPagedPoolCharge;
    FILETIME CreationTime;
    ushort TypeNameLength;
    void* TypeName;
    ushort ObjectNameLength;
    void* ObjectName;
    _TypeSpecificInformation_e__Union TypeSpecificInformation;
}