STARTUPINFOEXW

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFOW
{
    public uint cb;
    public IntPtr lpReserved;
    public IntPtr lpDesktop;
    public IntPtr lpTitle;
    public uint dwX;
    public uint dwY;
    public uint dwXSize;
    public uint dwYSize;
    public uint dwXCountChars;
    public uint dwYCountChars;
    public uint dwFillAttribute;
    public uint dwFlags;
    public ushort wShowWindow;
    public ushort cbReserved2;
    public IntPtr lpReserved2;
    public IntPtr hStdInput;
    public IntPtr hStdOutput;
    public IntPtr hStdError;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STARTUPINFOEXW
{
    public STARTUPINFOW StartupInfo;
    public IntPtr lpAttributeList;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STARTUPINFOW
    Public cb As UInteger
    Public lpReserved As IntPtr
    Public lpDesktop As IntPtr
    Public lpTitle As IntPtr
    Public dwX As UInteger
    Public dwY As UInteger
    Public dwXSize As UInteger
    Public dwYSize As UInteger
    Public dwXCountChars As UInteger
    Public dwYCountChars As UInteger
    Public dwFillAttribute As UInteger
    Public dwFlags As UInteger
    Public wShowWindow As UShort
    Public cbReserved2 As UShort
    Public lpReserved2 As IntPtr
    Public hStdInput As IntPtr
    Public hStdOutput As IntPtr
    Public hStdError As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STARTUPINFOEXW
    Public StartupInfo As STARTUPINFOW
    Public lpAttributeList As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class STARTUPINFOW(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("lpReserved", ctypes.c_void_p),
        ("lpDesktop", ctypes.c_void_p),
        ("lpTitle", ctypes.c_void_p),
        ("dwX", wintypes.DWORD),
        ("dwY", wintypes.DWORD),
        ("dwXSize", wintypes.DWORD),
        ("dwYSize", wintypes.DWORD),
        ("dwXCountChars", wintypes.DWORD),
        ("dwYCountChars", wintypes.DWORD),
        ("dwFillAttribute", wintypes.DWORD),
        ("dwFlags", wintypes.DWORD),
        ("wShowWindow", ctypes.c_ushort),
        ("cbReserved2", ctypes.c_ushort),
        ("lpReserved2", ctypes.c_void_p),
        ("hStdInput", ctypes.c_void_p),
        ("hStdOutput", ctypes.c_void_p),
        ("hStdError", ctypes.c_void_p),
    ]

class STARTUPINFOEXW(ctypes.Structure):
    _fields_ = [
        ("StartupInfo", STARTUPINFOW),
        ("lpAttributeList", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct STARTUPINFOW {
    pub cb: u32,
    pub lpReserved: *mut core::ffi::c_void,
    pub lpDesktop: *mut core::ffi::c_void,
    pub lpTitle: *mut core::ffi::c_void,
    pub dwX: u32,
    pub dwY: u32,
    pub dwXSize: u32,
    pub dwYSize: u32,
    pub dwXCountChars: u32,
    pub dwYCountChars: u32,
    pub dwFillAttribute: u32,
    pub dwFlags: u32,
    pub wShowWindow: u16,
    pub cbReserved2: u16,
    pub lpReserved2: *mut core::ffi::c_void,
    pub hStdInput: *mut core::ffi::c_void,
    pub hStdOutput: *mut core::ffi::c_void,
    pub hStdError: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct STARTUPINFOEXW {
    pub StartupInfo: STARTUPINFOW,
    pub lpAttributeList: *mut core::ffi::c_void,
}

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

type STARTUPINFOW struct {
	cb uint32
	lpReserved uintptr
	lpDesktop uintptr
	lpTitle uintptr
	dwX uint32
	dwY uint32
	dwXSize uint32
	dwYSize uint32
	dwXCountChars uint32
	dwYCountChars uint32
	dwFillAttribute uint32
	dwFlags uint32
	wShowWindow uint16
	cbReserved2 uint16
	lpReserved2 uintptr
	hStdInput uintptr
	hStdOutput uintptr
	hStdError uintptr
}

type STARTUPINFOEXW struct {
	StartupInfo STARTUPINFOW
	lpAttributeList uintptr
}

type
  STARTUPINFOW = record
    cb: DWORD;
    lpReserved: Pointer;
    lpDesktop: Pointer;
    lpTitle: Pointer;
    dwX: DWORD;
    dwY: DWORD;
    dwXSize: DWORD;
    dwYSize: DWORD;
    dwXCountChars: DWORD;
    dwYCountChars: DWORD;
    dwFillAttribute: DWORD;
    dwFlags: DWORD;
    wShowWindow: Word;
    cbReserved2: Word;
    lpReserved2: Pointer;
    hStdInput: Pointer;
    hStdOutput: Pointer;
    hStdError: Pointer;
  end;

  STARTUPINFOEXW = record
    StartupInfo: STARTUPINFOW;
    lpAttributeList: Pointer;
  end;

const STARTUPINFOW = extern struct {
    cb: u32,
    lpReserved: ?*anyopaque,
    lpDesktop: ?*anyopaque,
    lpTitle: ?*anyopaque,
    dwX: u32,
    dwY: u32,
    dwXSize: u32,
    dwYSize: u32,
    dwXCountChars: u32,
    dwYCountChars: u32,
    dwFillAttribute: u32,
    dwFlags: u32,
    wShowWindow: u16,
    cbReserved2: u16,
    lpReserved2: ?*anyopaque,
    hStdInput: ?*anyopaque,
    hStdOutput: ?*anyopaque,
    hStdError: ?*anyopaque,
};

const STARTUPINFOEXW = extern struct {
    StartupInfo: STARTUPINFOW,
    lpAttributeList: ?*anyopaque,
};

type
  STARTUPINFOW {.bycopy.} = object
    cb: uint32
    lpReserved: pointer
    lpDesktop: pointer
    lpTitle: pointer
    dwX: uint32
    dwY: uint32
    dwXSize: uint32
    dwYSize: uint32
    dwXCountChars: uint32
    dwYCountChars: uint32
    dwFillAttribute: uint32
    dwFlags: uint32
    wShowWindow: uint16
    cbReserved2: uint16
    lpReserved2: pointer
    hStdInput: pointer
    hStdOutput: pointer
    hStdError: pointer

  STARTUPINFOEXW {.bycopy.} = object
    StartupInfo: STARTUPINFOW
    lpAttributeList: pointer

struct STARTUPINFOW
{
    uint cb;
    void* lpReserved;
    void* lpDesktop;
    void* lpTitle;
    uint dwX;
    uint dwY;
    uint dwXSize;
    uint dwYSize;
    uint dwXCountChars;
    uint dwYCountChars;
    uint dwFillAttribute;
    uint dwFlags;
    ushort wShowWindow;
    ushort cbReserved2;
    void* lpReserved2;
    void* hStdInput;
    void* hStdOutput;
    void* hStdError;
}

struct STARTUPINFOEXW
{
    STARTUPINFOW StartupInfo;
    void* lpAttributeList;
}