FILEDESCRIPTORA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SIZE
{
    public int cx;
    public int cy;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POINTL
{
    public int x;
    public int y;
}

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

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct FILEDESCRIPTORA
{
    public uint dwFlags;
    public Guid clsid;
    public SIZE sizel;
    public POINTL pointl;
    public uint dwFileAttributes;
    public FILETIME ftCreationTime;
    public FILETIME ftLastAccessTime;
    public FILETIME ftLastWriteTime;
    public uint nFileSizeHigh;
    public uint nFileSizeLow;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)] public sbyte[] cFileName;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SIZE
    Public cx As Integer
    Public cy As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POINTL
    Public x As Integer
    Public y As Integer
End Structure

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

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure FILEDESCRIPTORA
    Public dwFlags As UInteger
    Public clsid As Guid
    Public sizel As SIZE
    Public pointl As POINTL
    Public dwFileAttributes As UInteger
    Public ftCreationTime As FILETIME
    Public ftLastAccessTime As FILETIME
    Public ftLastWriteTime As FILETIME
    Public nFileSizeHigh As UInteger
    Public nFileSizeLow As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=260)> Public cFileName() As SByte
End Structure

import ctypes
from ctypes import wintypes

class SIZE(ctypes.Structure):
    _fields_ = [
        ("cx", ctypes.c_int),
        ("cy", ctypes.c_int),
    ]

class POINTL(ctypes.Structure):
    _fields_ = [
        ("x", ctypes.c_int),
        ("y", ctypes.c_int),
    ]

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

class FILEDESCRIPTORA(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("dwFlags", wintypes.DWORD),
        ("clsid", GUID),
        ("sizel", SIZE),
        ("pointl", POINTL),
        ("dwFileAttributes", wintypes.DWORD),
        ("ftCreationTime", FILETIME),
        ("ftLastAccessTime", FILETIME),
        ("ftLastWriteTime", FILETIME),
        ("nFileSizeHigh", wintypes.DWORD),
        ("nFileSizeLow", wintypes.DWORD),
        ("cFileName", ctypes.c_byte * 260),
    ]

#[repr(C)]
pub struct SIZE {
    pub cx: i32,
    pub cy: i32,
}

#[repr(C)]
pub struct POINTL {
    pub x: i32,
    pub y: i32,
}

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

#[repr(C, packed(1))]
pub struct FILEDESCRIPTORA {
    pub dwFlags: u32,
    pub clsid: GUID,
    pub sizel: SIZE,
    pub pointl: POINTL,
    pub dwFileAttributes: u32,
    pub ftCreationTime: FILETIME,
    pub ftLastAccessTime: FILETIME,
    pub ftLastWriteTime: FILETIME,
    pub nFileSizeHigh: u32,
    pub nFileSizeLow: u32,
    pub cFileName: [i8; 260],
}

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

type SIZE struct {
	cx int32
	cy int32
}

type POINTL struct {
	x int32
	y int32
}

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type FILEDESCRIPTORA struct {
	dwFlags uint32
	clsid windows.GUID
	sizel SIZE
	pointl POINTL
	dwFileAttributes uint32
	ftCreationTime FILETIME
	ftLastAccessTime FILETIME
	ftLastWriteTime FILETIME
	nFileSizeHigh uint32
	nFileSizeLow uint32
	cFileName [260]int8
}

type
  SIZE = record
    cx: Integer;
    cy: Integer;
  end;

  POINTL = record
    x: Integer;
    y: Integer;
  end;

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

  FILEDESCRIPTORA = packed record
    dwFlags: DWORD;
    clsid: TGUID;
    sizel: SIZE;
    pointl: POINTL;
    dwFileAttributes: DWORD;
    ftCreationTime: FILETIME;
    ftLastAccessTime: FILETIME;
    ftLastWriteTime: FILETIME;
    nFileSizeHigh: DWORD;
    nFileSizeLow: DWORD;
    cFileName: array[0..259] of Shortint;
  end;

const SIZE = extern struct {
    cx: i32,
    cy: i32,
};

const POINTL = extern struct {
    x: i32,
    y: i32,
};

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

const FILEDESCRIPTORA = extern struct {
    dwFlags: u32,
    clsid: GUID,
    sizel: SIZE,
    pointl: POINTL,
    dwFileAttributes: u32,
    ftCreationTime: FILETIME,
    ftLastAccessTime: FILETIME,
    ftLastWriteTime: FILETIME,
    nFileSizeHigh: u32,
    nFileSizeLow: u32,
    cFileName: [260]i8,
};

type
  SIZE {.bycopy.} = object
    cx: int32
    cy: int32

  POINTL {.bycopy.} = object
    x: int32
    y: int32

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

  FILEDESCRIPTORA {.packed.} = object
    dwFlags: uint32
    clsid: GUID
    sizel: SIZE
    pointl: POINTL
    dwFileAttributes: uint32
    ftCreationTime: FILETIME
    ftLastAccessTime: FILETIME
    ftLastWriteTime: FILETIME
    nFileSizeHigh: uint32
    nFileSizeLow: uint32
    cFileName: array[260, int8]

struct SIZE
{
    int cx;
    int cy;
}

struct POINTL
{
    int x;
    int y;
}

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

align(1)
struct FILEDESCRIPTORA
{
    uint dwFlags;
    GUID clsid;
    SIZE sizel;
    POINTL pointl;
    uint dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    uint nFileSizeHigh;
    uint nFileSizeLow;
    byte[260] cFileName;
}