WINDOW_ACTION

using System;
using System.Runtime.InteropServices;

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

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECT
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WINDOW_ACTION
{
    public int kinds;
    public int modifiers;
    [MarshalAs(UnmanagedType.Bool)] public bool visible;
    public POINT position;
    public SIZE size;
    public IntPtr insertAfter;
    public int placementState;
    public RECT normalRect;
    public RECT workArea;
    public uint dpi;
    public POINT pointOnMonitor;
    public uint monitorTopologyId;
}

Imports System.Runtime.InteropServices

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

<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 RECT
    Public left As Integer
    Public top As Integer
    Public right As Integer
    Public bottom As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WINDOW_ACTION
    Public kinds As Integer
    Public modifiers As Integer
    <MarshalAs(UnmanagedType.Bool)> Public visible As Boolean
    Public position As POINT
    Public size As SIZE
    Public insertAfter As IntPtr
    Public placementState As Integer
    Public normalRect As RECT
    Public workArea As RECT
    Public dpi As UInteger
    Public pointOnMonitor As POINT
    Public monitorTopologyId As UInteger
End Structure

import ctypes
from ctypes import wintypes

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

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

class RECT(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

class WINDOW_ACTION(ctypes.Structure):
    _fields_ = [
        ("kinds", ctypes.c_int),
        ("modifiers", ctypes.c_int),
        ("visible", wintypes.BOOL),
        ("position", POINT),
        ("size", SIZE),
        ("insertAfter", ctypes.c_void_p),
        ("placementState", ctypes.c_int),
        ("normalRect", RECT),
        ("workArea", RECT),
        ("dpi", wintypes.DWORD),
        ("pointOnMonitor", POINT),
        ("monitorTopologyId", wintypes.DWORD),
    ]

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

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

#[repr(C)]
pub struct RECT {
    pub left: i32,
    pub top: i32,
    pub right: i32,
    pub bottom: i32,
}

#[repr(C)]
pub struct WINDOW_ACTION {
    pub kinds: i32,
    pub modifiers: i32,
    pub visible: i32,
    pub position: POINT,
    pub size: SIZE,
    pub insertAfter: *mut core::ffi::c_void,
    pub placementState: i32,
    pub normalRect: RECT,
    pub workArea: RECT,
    pub dpi: u32,
    pub pointOnMonitor: POINT,
    pub monitorTopologyId: u32,
}

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

type POINT struct {
	x int32
	y int32
}

type SIZE struct {
	cx int32
	cy int32
}

type RECT struct {
	left int32
	top int32
	right int32
	bottom int32
}

type WINDOW_ACTION struct {
	kinds int32
	modifiers int32
	visible int32
	position POINT
	size SIZE
	insertAfter uintptr
	placementState int32
	normalRect RECT
	workArea RECT
	dpi uint32
	pointOnMonitor POINT
	monitorTopologyId uint32
}

type
  POINT = record
    x: Integer;
    y: Integer;
  end;

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

  RECT = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  WINDOW_ACTION = record
    kinds: Integer;
    modifiers: Integer;
    visible: BOOL;
    position: POINT;
    size: SIZE;
    insertAfter: Pointer;
    placementState: Integer;
    normalRect: RECT;
    workArea: RECT;
    dpi: DWORD;
    pointOnMonitor: POINT;
    monitorTopologyId: DWORD;
  end;

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

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

const RECT = extern struct {
    left: i32,
    top: i32,
    right: i32,
    bottom: i32,
};

const WINDOW_ACTION = extern struct {
    kinds: i32,
    modifiers: i32,
    visible: i32,
    position: POINT,
    size: SIZE,
    insertAfter: ?*anyopaque,
    placementState: i32,
    normalRect: RECT,
    workArea: RECT,
    dpi: u32,
    pointOnMonitor: POINT,
    monitorTopologyId: u32,
};

type
  POINT {.bycopy.} = object
    x: int32
    y: int32

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

  RECT {.bycopy.} = object
    left: int32
    top: int32
    right: int32
    bottom: int32

  WINDOW_ACTION {.bycopy.} = object
    kinds: int32
    modifiers: int32
    visible: int32
    position: POINT
    size: SIZE
    insertAfter: pointer
    placementState: int32
    normalRect: RECT
    workArea: RECT
    dpi: uint32
    pointOnMonitor: POINT
    monitorTopologyId: uint32

struct POINT
{
    int x;
    int y;
}

struct SIZE
{
    int cx;
    int cy;
}

struct RECT
{
    int left;
    int top;
    int right;
    int bottom;
}

struct WINDOW_ACTION
{
    int kinds;
    int modifiers;
    int visible;
    POINT position;
    SIZE size;
    void* insertAfter;
    int placementState;
    RECT normalRect;
    RECT workArea;
    uint dpi;
    POINT pointOnMonitor;
    uint monitorTopologyId;
}