IMEPROA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DATETIME
{
    public ushort year;
    public ushort month;
    public ushort day;
    public ushort hour;
    public ushort min;
    public ushort sec;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IMEPROA
{
    public IntPtr hWnd;
    public DATETIME InstDate;
    public uint wVersion;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)] public byte[] szDescription;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)] public byte[] szName;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)] public byte[] szOptions;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DATETIME
    Public year As UShort
    Public month As UShort
    Public day As UShort
    Public hour As UShort
    Public min As UShort
    Public sec As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IMEPROA
    Public hWnd As IntPtr
    Public InstDate As DATETIME
    Public wVersion As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=50)> Public szDescription() As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=80)> Public szName() As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=30)> Public szOptions() As Byte
End Structure

import ctypes
from ctypes import wintypes

class DATETIME(ctypes.Structure):
    _fields_ = [
        ("year", ctypes.c_ushort),
        ("month", ctypes.c_ushort),
        ("day", ctypes.c_ushort),
        ("hour", ctypes.c_ushort),
        ("min", ctypes.c_ushort),
        ("sec", ctypes.c_ushort),
    ]

class IMEPROA(ctypes.Structure):
    _fields_ = [
        ("hWnd", ctypes.c_void_p),
        ("InstDate", DATETIME),
        ("wVersion", wintypes.DWORD),
        ("szDescription", ctypes.c_ubyte * 50),
        ("szName", ctypes.c_ubyte * 80),
        ("szOptions", ctypes.c_ubyte * 30),
    ]

#[repr(C)]
pub struct DATETIME {
    pub year: u16,
    pub month: u16,
    pub day: u16,
    pub hour: u16,
    pub min: u16,
    pub sec: u16,
}

#[repr(C)]
pub struct IMEPROA {
    pub hWnd: *mut core::ffi::c_void,
    pub InstDate: DATETIME,
    pub wVersion: u32,
    pub szDescription: [u8; 50],
    pub szName: [u8; 80],
    pub szOptions: [u8; 30],
}

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

type DATETIME struct {
	year uint16
	month uint16
	day uint16
	hour uint16
	min uint16
	sec uint16
}

type IMEPROA struct {
	hWnd uintptr
	InstDate DATETIME
	wVersion uint32
	szDescription [50]byte
	szName [80]byte
	szOptions [30]byte
}

type
  DATETIME = record
    year: Word;
    month: Word;
    day: Word;
    hour: Word;
    min: Word;
    sec: Word;
  end;

  IMEPROA = record
    hWnd: Pointer;
    InstDate: DATETIME;
    wVersion: DWORD;
    szDescription: array[0..49] of Byte;
    szName: array[0..79] of Byte;
    szOptions: array[0..29] of Byte;
  end;

const DATETIME = extern struct {
    year: u16,
    month: u16,
    day: u16,
    hour: u16,
    min: u16,
    sec: u16,
};

const IMEPROA = extern struct {
    hWnd: ?*anyopaque,
    InstDate: DATETIME,
    wVersion: u32,
    szDescription: [50]u8,
    szName: [80]u8,
    szOptions: [30]u8,
};

type
  DATETIME {.bycopy.} = object
    year: uint16
    month: uint16
    day: uint16
    hour: uint16
    min: uint16
    sec: uint16

  IMEPROA {.bycopy.} = object
    hWnd: pointer
    InstDate: DATETIME
    wVersion: uint32
    szDescription: array[50, uint8]
    szName: array[80, uint8]
    szOptions: array[30, uint8]

struct DATETIME
{
    ushort year;
    ushort month;
    ushort day;
    ushort hour;
    ushort min;
    ushort sec;
}

struct IMEPROA
{
    void* hWnd;
    DATETIME InstDate;
    uint wVersion;
    ubyte[50] szDescription;
    ubyte[80] szName;
    ubyte[30] szOptions;
}