DRIVER_INFO_8W

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 DRIVER_INFO_8W
{
    public uint cVersion;
    public IntPtr pName;
    public IntPtr pEnvironment;
    public IntPtr pDriverPath;
    public IntPtr pDataFile;
    public IntPtr pConfigFile;
    public IntPtr pHelpFile;
    public IntPtr pDependentFiles;
    public IntPtr pMonitorName;
    public IntPtr pDefaultDataType;
    public IntPtr pszzPreviousNames;
    public FILETIME ftDriverDate;
    public ulong dwlDriverVersion;
    public IntPtr pszMfgName;
    public IntPtr pszOEMUrl;
    public IntPtr pszHardwareID;
    public IntPtr pszProvider;
    public IntPtr pszPrintProcessor;
    public IntPtr pszVendorSetup;
    public IntPtr pszzColorProfiles;
    public IntPtr pszInfPath;
    public uint dwPrinterDriverAttributes;
    public IntPtr pszzCoreDriverDependencies;
    public FILETIME ftMinInboxDriverVerDate;
    public ulong dwlMinInboxDriverVerVersion;
}

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 DRIVER_INFO_8W
    Public cVersion As UInteger
    Public pName As IntPtr
    Public pEnvironment As IntPtr
    Public pDriverPath As IntPtr
    Public pDataFile As IntPtr
    Public pConfigFile As IntPtr
    Public pHelpFile As IntPtr
    Public pDependentFiles As IntPtr
    Public pMonitorName As IntPtr
    Public pDefaultDataType As IntPtr
    Public pszzPreviousNames As IntPtr
    Public ftDriverDate As FILETIME
    Public dwlDriverVersion As ULong
    Public pszMfgName As IntPtr
    Public pszOEMUrl As IntPtr
    Public pszHardwareID As IntPtr
    Public pszProvider As IntPtr
    Public pszPrintProcessor As IntPtr
    Public pszVendorSetup As IntPtr
    Public pszzColorProfiles As IntPtr
    Public pszInfPath As IntPtr
    Public dwPrinterDriverAttributes As UInteger
    Public pszzCoreDriverDependencies As IntPtr
    Public ftMinInboxDriverVerDate As FILETIME
    Public dwlMinInboxDriverVerVersion As ULong
End Structure

import ctypes
from ctypes import wintypes

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

class DRIVER_INFO_8W(ctypes.Structure):
    _fields_ = [
        ("cVersion", wintypes.DWORD),
        ("pName", ctypes.c_void_p),
        ("pEnvironment", ctypes.c_void_p),
        ("pDriverPath", ctypes.c_void_p),
        ("pDataFile", ctypes.c_void_p),
        ("pConfigFile", ctypes.c_void_p),
        ("pHelpFile", ctypes.c_void_p),
        ("pDependentFiles", ctypes.c_void_p),
        ("pMonitorName", ctypes.c_void_p),
        ("pDefaultDataType", ctypes.c_void_p),
        ("pszzPreviousNames", ctypes.c_void_p),
        ("ftDriverDate", FILETIME),
        ("dwlDriverVersion", ctypes.c_ulonglong),
        ("pszMfgName", ctypes.c_void_p),
        ("pszOEMUrl", ctypes.c_void_p),
        ("pszHardwareID", ctypes.c_void_p),
        ("pszProvider", ctypes.c_void_p),
        ("pszPrintProcessor", ctypes.c_void_p),
        ("pszVendorSetup", ctypes.c_void_p),
        ("pszzColorProfiles", ctypes.c_void_p),
        ("pszInfPath", ctypes.c_void_p),
        ("dwPrinterDriverAttributes", wintypes.DWORD),
        ("pszzCoreDriverDependencies", ctypes.c_void_p),
        ("ftMinInboxDriverVerDate", FILETIME),
        ("dwlMinInboxDriverVerVersion", ctypes.c_ulonglong),
    ]

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

#[repr(C)]
pub struct DRIVER_INFO_8W {
    pub cVersion: u32,
    pub pName: *mut core::ffi::c_void,
    pub pEnvironment: *mut core::ffi::c_void,
    pub pDriverPath: *mut core::ffi::c_void,
    pub pDataFile: *mut core::ffi::c_void,
    pub pConfigFile: *mut core::ffi::c_void,
    pub pHelpFile: *mut core::ffi::c_void,
    pub pDependentFiles: *mut core::ffi::c_void,
    pub pMonitorName: *mut core::ffi::c_void,
    pub pDefaultDataType: *mut core::ffi::c_void,
    pub pszzPreviousNames: *mut core::ffi::c_void,
    pub ftDriverDate: FILETIME,
    pub dwlDriverVersion: u64,
    pub pszMfgName: *mut core::ffi::c_void,
    pub pszOEMUrl: *mut core::ffi::c_void,
    pub pszHardwareID: *mut core::ffi::c_void,
    pub pszProvider: *mut core::ffi::c_void,
    pub pszPrintProcessor: *mut core::ffi::c_void,
    pub pszVendorSetup: *mut core::ffi::c_void,
    pub pszzColorProfiles: *mut core::ffi::c_void,
    pub pszInfPath: *mut core::ffi::c_void,
    pub dwPrinterDriverAttributes: u32,
    pub pszzCoreDriverDependencies: *mut core::ffi::c_void,
    pub ftMinInboxDriverVerDate: FILETIME,
    pub dwlMinInboxDriverVerVersion: u64,
}

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

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type DRIVER_INFO_8W struct {
	cVersion uint32
	pName uintptr
	pEnvironment uintptr
	pDriverPath uintptr
	pDataFile uintptr
	pConfigFile uintptr
	pHelpFile uintptr
	pDependentFiles uintptr
	pMonitorName uintptr
	pDefaultDataType uintptr
	pszzPreviousNames uintptr
	ftDriverDate FILETIME
	dwlDriverVersion uint64
	pszMfgName uintptr
	pszOEMUrl uintptr
	pszHardwareID uintptr
	pszProvider uintptr
	pszPrintProcessor uintptr
	pszVendorSetup uintptr
	pszzColorProfiles uintptr
	pszInfPath uintptr
	dwPrinterDriverAttributes uint32
	pszzCoreDriverDependencies uintptr
	ftMinInboxDriverVerDate FILETIME
	dwlMinInboxDriverVerVersion uint64
}

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

  DRIVER_INFO_8W = record
    cVersion: DWORD;
    pName: Pointer;
    pEnvironment: Pointer;
    pDriverPath: Pointer;
    pDataFile: Pointer;
    pConfigFile: Pointer;
    pHelpFile: Pointer;
    pDependentFiles: Pointer;
    pMonitorName: Pointer;
    pDefaultDataType: Pointer;
    pszzPreviousNames: Pointer;
    ftDriverDate: FILETIME;
    dwlDriverVersion: UInt64;
    pszMfgName: Pointer;
    pszOEMUrl: Pointer;
    pszHardwareID: Pointer;
    pszProvider: Pointer;
    pszPrintProcessor: Pointer;
    pszVendorSetup: Pointer;
    pszzColorProfiles: Pointer;
    pszInfPath: Pointer;
    dwPrinterDriverAttributes: DWORD;
    pszzCoreDriverDependencies: Pointer;
    ftMinInboxDriverVerDate: FILETIME;
    dwlMinInboxDriverVerVersion: UInt64;
  end;

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

const DRIVER_INFO_8W = extern struct {
    cVersion: u32,
    pName: ?*anyopaque,
    pEnvironment: ?*anyopaque,
    pDriverPath: ?*anyopaque,
    pDataFile: ?*anyopaque,
    pConfigFile: ?*anyopaque,
    pHelpFile: ?*anyopaque,
    pDependentFiles: ?*anyopaque,
    pMonitorName: ?*anyopaque,
    pDefaultDataType: ?*anyopaque,
    pszzPreviousNames: ?*anyopaque,
    ftDriverDate: FILETIME,
    dwlDriverVersion: u64,
    pszMfgName: ?*anyopaque,
    pszOEMUrl: ?*anyopaque,
    pszHardwareID: ?*anyopaque,
    pszProvider: ?*anyopaque,
    pszPrintProcessor: ?*anyopaque,
    pszVendorSetup: ?*anyopaque,
    pszzColorProfiles: ?*anyopaque,
    pszInfPath: ?*anyopaque,
    dwPrinterDriverAttributes: u32,
    pszzCoreDriverDependencies: ?*anyopaque,
    ftMinInboxDriverVerDate: FILETIME,
    dwlMinInboxDriverVerVersion: u64,
};

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

  DRIVER_INFO_8W {.bycopy.} = object
    cVersion: uint32
    pName: pointer
    pEnvironment: pointer
    pDriverPath: pointer
    pDataFile: pointer
    pConfigFile: pointer
    pHelpFile: pointer
    pDependentFiles: pointer
    pMonitorName: pointer
    pDefaultDataType: pointer
    pszzPreviousNames: pointer
    ftDriverDate: FILETIME
    dwlDriverVersion: uint64
    pszMfgName: pointer
    pszOEMUrl: pointer
    pszHardwareID: pointer
    pszProvider: pointer
    pszPrintProcessor: pointer
    pszVendorSetup: pointer
    pszzColorProfiles: pointer
    pszInfPath: pointer
    dwPrinterDriverAttributes: uint32
    pszzCoreDriverDependencies: pointer
    ftMinInboxDriverVerDate: FILETIME
    dwlMinInboxDriverVerVersion: uint64

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct DRIVER_INFO_8W
{
    uint cVersion;
    void* pName;
    void* pEnvironment;
    void* pDriverPath;
    void* pDataFile;
    void* pConfigFile;
    void* pHelpFile;
    void* pDependentFiles;
    void* pMonitorName;
    void* pDefaultDataType;
    void* pszzPreviousNames;
    FILETIME ftDriverDate;
    ulong dwlDriverVersion;
    void* pszMfgName;
    void* pszOEMUrl;
    void* pszHardwareID;
    void* pszProvider;
    void* pszPrintProcessor;
    void* pszVendorSetup;
    void* pszzColorProfiles;
    void* pszInfPath;
    uint dwPrinterDriverAttributes;
    void* pszzCoreDriverDependencies;
    FILETIME ftMinInboxDriverVerDate;
    ulong dwlMinInboxDriverVerVersion;
}