pluginResource2

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct pluginResource
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string alias;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string name;
    public IntPtr resourceFileContents;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string fileExtension;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string resourcePluginType;
    public byte isDiscoverable;
    public int resourceType;
    public uint pceIconSize;
    public IntPtr iconContents;
    public uint pcePluginBlobSize;
    public IntPtr blobContents;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct pluginResource2
{
    public pluginResource resourceV1;
    public uint pceFileAssocListSize;
    public IntPtr fileAssocList;
    public IntPtr securityDescriptor;
    public uint pceFolderListSize;
    public IntPtr folderList;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure pluginResource
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public alias As String
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public name As String
    Public resourceFileContents As IntPtr
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public fileExtension As String
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public resourcePluginType As String
    Public isDiscoverable As Byte
    Public resourceType As Integer
    Public pceIconSize As UInteger
    Public iconContents As IntPtr
    Public pcePluginBlobSize As UInteger
    Public blobContents As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure pluginResource2
    Public resourceV1 As pluginResource
    Public pceFileAssocListSize As UInteger
    Public fileAssocList As IntPtr
    Public securityDescriptor As IntPtr
    Public pceFolderListSize As UInteger
    Public folderList As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class pluginResource(ctypes.Structure):
    _fields_ = [
        ("alias", ctypes.c_wchar * 256),
        ("name", ctypes.c_wchar * 256),
        ("resourceFileContents", ctypes.c_void_p),
        ("fileExtension", ctypes.c_wchar * 256),
        ("resourcePluginType", ctypes.c_wchar * 256),
        ("isDiscoverable", ctypes.c_ubyte),
        ("resourceType", ctypes.c_int),
        ("pceIconSize", wintypes.DWORD),
        ("iconContents", ctypes.c_void_p),
        ("pcePluginBlobSize", wintypes.DWORD),
        ("blobContents", ctypes.c_void_p),
    ]

class pluginResource2(ctypes.Structure):
    _fields_ = [
        ("resourceV1", pluginResource),
        ("pceFileAssocListSize", wintypes.DWORD),
        ("fileAssocList", ctypes.c_void_p),
        ("securityDescriptor", ctypes.c_void_p),
        ("pceFolderListSize", wintypes.DWORD),
        ("folderList", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct pluginResource {
    pub alias: [u16; 256],
    pub name: [u16; 256],
    pub resourceFileContents: *mut core::ffi::c_void,
    pub fileExtension: [u16; 256],
    pub resourcePluginType: [u16; 256],
    pub isDiscoverable: u8,
    pub resourceType: i32,
    pub pceIconSize: u32,
    pub iconContents: *mut core::ffi::c_void,
    pub pcePluginBlobSize: u32,
    pub blobContents: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct pluginResource2 {
    pub resourceV1: pluginResource,
    pub pceFileAssocListSize: u32,
    pub fileAssocList: *mut core::ffi::c_void,
    pub securityDescriptor: *mut core::ffi::c_void,
    pub pceFolderListSize: u32,
    pub folderList: *mut core::ffi::c_void,
}

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

type pluginResource struct {
	alias [256]uint16
	name [256]uint16
	resourceFileContents uintptr
	fileExtension [256]uint16
	resourcePluginType [256]uint16
	isDiscoverable byte
	resourceType int32
	pceIconSize uint32
	iconContents uintptr
	pcePluginBlobSize uint32
	blobContents uintptr
}

type pluginResource2 struct {
	resourceV1 pluginResource
	pceFileAssocListSize uint32
	fileAssocList uintptr
	securityDescriptor uintptr
	pceFolderListSize uint32
	folderList uintptr
}

type
  pluginResource = record
    alias: array[0..255] of WideChar;
    name: array[0..255] of WideChar;
    resourceFileContents: Pointer;
    fileExtension: array[0..255] of WideChar;
    resourcePluginType: array[0..255] of WideChar;
    isDiscoverable: Byte;
    resourceType: Integer;
    pceIconSize: DWORD;
    iconContents: Pointer;
    pcePluginBlobSize: DWORD;
    blobContents: Pointer;
  end;

  pluginResource2 = record
    resourceV1: pluginResource;
    pceFileAssocListSize: DWORD;
    fileAssocList: Pointer;
    securityDescriptor: Pointer;
    pceFolderListSize: DWORD;
    folderList: Pointer;
  end;

const pluginResource = extern struct {
    alias: [256]u16,
    name: [256]u16,
    resourceFileContents: ?*anyopaque,
    fileExtension: [256]u16,
    resourcePluginType: [256]u16,
    isDiscoverable: u8,
    resourceType: i32,
    pceIconSize: u32,
    iconContents: ?*anyopaque,
    pcePluginBlobSize: u32,
    blobContents: ?*anyopaque,
};

const pluginResource2 = extern struct {
    resourceV1: pluginResource,
    pceFileAssocListSize: u32,
    fileAssocList: ?*anyopaque,
    securityDescriptor: ?*anyopaque,
    pceFolderListSize: u32,
    folderList: ?*anyopaque,
};

type
  pluginResource {.bycopy.} = object
    alias: array[256, uint16]
    name: array[256, uint16]
    resourceFileContents: pointer
    fileExtension: array[256, uint16]
    resourcePluginType: array[256, uint16]
    isDiscoverable: uint8
    resourceType: int32
    pceIconSize: uint32
    iconContents: pointer
    pcePluginBlobSize: uint32
    blobContents: pointer

  pluginResource2 {.bycopy.} = object
    resourceV1: pluginResource
    pceFileAssocListSize: uint32
    fileAssocList: pointer
    securityDescriptor: pointer
    pceFolderListSize: uint32
    folderList: pointer

struct pluginResource
{
    wchar[256] alias;
    wchar[256] name;
    void* resourceFileContents;
    wchar[256] fileExtension;
    wchar[256] resourcePluginType;
    ubyte isDiscoverable;
    int resourceType;
    uint pceIconSize;
    void* iconContents;
    uint pcePluginBlobSize;
    void* blobContents;
}

struct pluginResource2
{
    pluginResource resourceV1;
    uint pceFileAssocListSize;
    void* fileAssocList;
    void* securityDescriptor;
    uint pceFolderListSize;
    void* folderList;
}