DIAGNOSTIC_REPORT_DATA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DIAGNOSTIC_REPORT_PARAMETER
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)] public string name;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string value;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DIAGNOSTIC_REPORT_SIGNATURE
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 65)] public string eventName;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] public DIAGNOSTIC_REPORT_PARAMETER[] parameters;
}

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DIAGNOSTIC_REPORT_DATA
{
    public DIAGNOSTIC_REPORT_SIGNATURE signature;
    public Guid bucketId;
    public Guid reportId;
    public FILETIME creationTime;
    public ulong sizeInBytes;
    public IntPtr cabId;
    public uint reportStatus;
    public Guid reportIntegratorId;
    public IntPtr fileNames;
    public uint fileCount;
    public IntPtr friendlyEventName;
    public IntPtr applicationName;
    public IntPtr applicationPath;
    public IntPtr description;
    public IntPtr bucketIdString;
    public ulong legacyBucketId;
    public IntPtr reportKey;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DIAGNOSTIC_REPORT_PARAMETER
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=129)> Public name As String
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=260)> Public value As String
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DIAGNOSTIC_REPORT_SIGNATURE
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=65)> Public eventName As String
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=10)> Public parameters() As DIAGNOSTIC_REPORT_PARAMETER
End Structure

<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 DIAGNOSTIC_REPORT_DATA
    Public signature As DIAGNOSTIC_REPORT_SIGNATURE
    Public bucketId As Guid
    Public reportId As Guid
    Public creationTime As FILETIME
    Public sizeInBytes As ULong
    Public cabId As IntPtr
    Public reportStatus As UInteger
    Public reportIntegratorId As Guid
    Public fileNames As IntPtr
    Public fileCount As UInteger
    Public friendlyEventName As IntPtr
    Public applicationName As IntPtr
    Public applicationPath As IntPtr
    Public description As IntPtr
    Public bucketIdString As IntPtr
    Public legacyBucketId As ULong
    Public reportKey As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class DIAGNOSTIC_REPORT_PARAMETER(ctypes.Structure):
    _fields_ = [
        ("name", ctypes.c_wchar * 129),
        ("value", ctypes.c_wchar * 260),
    ]

class DIAGNOSTIC_REPORT_SIGNATURE(ctypes.Structure):
    _fields_ = [
        ("eventName", ctypes.c_wchar * 65),
        ("parameters", DIAGNOSTIC_REPORT_PARAMETER * 10),
    ]

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

class DIAGNOSTIC_REPORT_DATA(ctypes.Structure):
    _fields_ = [
        ("signature", DIAGNOSTIC_REPORT_SIGNATURE),
        ("bucketId", GUID),
        ("reportId", GUID),
        ("creationTime", FILETIME),
        ("sizeInBytes", ctypes.c_ulonglong),
        ("cabId", ctypes.c_void_p),
        ("reportStatus", wintypes.DWORD),
        ("reportIntegratorId", GUID),
        ("fileNames", ctypes.c_void_p),
        ("fileCount", wintypes.DWORD),
        ("friendlyEventName", ctypes.c_void_p),
        ("applicationName", ctypes.c_void_p),
        ("applicationPath", ctypes.c_void_p),
        ("description", ctypes.c_void_p),
        ("bucketIdString", ctypes.c_void_p),
        ("legacyBucketId", ctypes.c_ulonglong),
        ("reportKey", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct DIAGNOSTIC_REPORT_PARAMETER {
    pub name: [u16; 129],
    pub value: [u16; 260],
}

#[repr(C)]
pub struct DIAGNOSTIC_REPORT_SIGNATURE {
    pub eventName: [u16; 65],
    pub parameters: [DIAGNOSTIC_REPORT_PARAMETER; 10],
}

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

#[repr(C)]
pub struct DIAGNOSTIC_REPORT_DATA {
    pub signature: DIAGNOSTIC_REPORT_SIGNATURE,
    pub bucketId: GUID,
    pub reportId: GUID,
    pub creationTime: FILETIME,
    pub sizeInBytes: u64,
    pub cabId: *mut core::ffi::c_void,
    pub reportStatus: u32,
    pub reportIntegratorId: GUID,
    pub fileNames: *mut core::ffi::c_void,
    pub fileCount: u32,
    pub friendlyEventName: *mut core::ffi::c_void,
    pub applicationName: *mut core::ffi::c_void,
    pub applicationPath: *mut core::ffi::c_void,
    pub description: *mut core::ffi::c_void,
    pub bucketIdString: *mut core::ffi::c_void,
    pub legacyBucketId: u64,
    pub reportKey: *mut core::ffi::c_void,
}

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

type DIAGNOSTIC_REPORT_PARAMETER struct {
	name [129]uint16
	value [260]uint16
}

type DIAGNOSTIC_REPORT_SIGNATURE struct {
	eventName [65]uint16
	parameters [10]DIAGNOSTIC_REPORT_PARAMETER
}

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type DIAGNOSTIC_REPORT_DATA struct {
	signature DIAGNOSTIC_REPORT_SIGNATURE
	bucketId windows.GUID
	reportId windows.GUID
	creationTime FILETIME
	sizeInBytes uint64
	cabId uintptr
	reportStatus uint32
	reportIntegratorId windows.GUID
	fileNames uintptr
	fileCount uint32
	friendlyEventName uintptr
	applicationName uintptr
	applicationPath uintptr
	description uintptr
	bucketIdString uintptr
	legacyBucketId uint64
	reportKey uintptr
}

type
  DIAGNOSTIC_REPORT_PARAMETER = record
    name: array[0..128] of WideChar;
    value: array[0..259] of WideChar;
  end;

  DIAGNOSTIC_REPORT_SIGNATURE = record
    eventName: array[0..64] of WideChar;
    parameters: array[0..9] of DIAGNOSTIC_REPORT_PARAMETER;
  end;

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

  DIAGNOSTIC_REPORT_DATA = record
    signature: DIAGNOSTIC_REPORT_SIGNATURE;
    bucketId: TGUID;
    reportId: TGUID;
    creationTime: FILETIME;
    sizeInBytes: UInt64;
    cabId: Pointer;
    reportStatus: DWORD;
    reportIntegratorId: TGUID;
    fileNames: Pointer;
    fileCount: DWORD;
    friendlyEventName: Pointer;
    applicationName: Pointer;
    applicationPath: Pointer;
    description: Pointer;
    bucketIdString: Pointer;
    legacyBucketId: UInt64;
    reportKey: Pointer;
  end;

const DIAGNOSTIC_REPORT_PARAMETER = extern struct {
    name: [129]u16,
    value: [260]u16,
};

const DIAGNOSTIC_REPORT_SIGNATURE = extern struct {
    eventName: [65]u16,
    parameters: [10]DIAGNOSTIC_REPORT_PARAMETER,
};

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

const DIAGNOSTIC_REPORT_DATA = extern struct {
    signature: DIAGNOSTIC_REPORT_SIGNATURE,
    bucketId: GUID,
    reportId: GUID,
    creationTime: FILETIME,
    sizeInBytes: u64,
    cabId: ?*anyopaque,
    reportStatus: u32,
    reportIntegratorId: GUID,
    fileNames: ?*anyopaque,
    fileCount: u32,
    friendlyEventName: ?*anyopaque,
    applicationName: ?*anyopaque,
    applicationPath: ?*anyopaque,
    description: ?*anyopaque,
    bucketIdString: ?*anyopaque,
    legacyBucketId: u64,
    reportKey: ?*anyopaque,
};

type
  DIAGNOSTIC_REPORT_PARAMETER {.bycopy.} = object
    name: array[129, uint16]
    value: array[260, uint16]

  DIAGNOSTIC_REPORT_SIGNATURE {.bycopy.} = object
    eventName: array[65, uint16]
    parameters: array[10, DIAGNOSTIC_REPORT_PARAMETER]

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

  DIAGNOSTIC_REPORT_DATA {.bycopy.} = object
    signature: DIAGNOSTIC_REPORT_SIGNATURE
    bucketId: GUID
    reportId: GUID
    creationTime: FILETIME
    sizeInBytes: uint64
    cabId: pointer
    reportStatus: uint32
    reportIntegratorId: GUID
    fileNames: pointer
    fileCount: uint32
    friendlyEventName: pointer
    applicationName: pointer
    applicationPath: pointer
    description: pointer
    bucketIdString: pointer
    legacyBucketId: uint64
    reportKey: pointer

struct DIAGNOSTIC_REPORT_PARAMETER
{
    wchar[129] name;
    wchar[260] value;
}

struct DIAGNOSTIC_REPORT_SIGNATURE
{
    wchar[65] eventName;
    DIAGNOSTIC_REPORT_PARAMETER[10] parameters;
}

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct DIAGNOSTIC_REPORT_DATA
{
    DIAGNOSTIC_REPORT_SIGNATURE signature;
    GUID bucketId;
    GUID reportId;
    FILETIME creationTime;
    ulong sizeInBytes;
    void* cabId;
    uint reportStatus;
    GUID reportIntegratorId;
    void* fileNames;
    uint fileCount;
    void* friendlyEventName;
    void* applicationName;
    void* applicationPath;
    void* description;
    void* bucketIdString;
    ulong legacyBucketId;
    void* reportKey;
}