HypothesisResult

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HYPOTHESIS
{
    public IntPtr pwszClassName;
    public IntPtr pwszDescription;
    public uint celt;
    public IntPtr rgAttributes;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HypothesisResult
{
    public HYPOTHESIS hypothesis;
    public int pathStatus;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HYPOTHESIS
    Public pwszClassName As IntPtr
    Public pwszDescription As IntPtr
    Public celt As UInteger
    Public rgAttributes As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HypothesisResult
    Public hypothesis As HYPOTHESIS
    Public pathStatus As Integer
End Structure

import ctypes
from ctypes import wintypes

class HYPOTHESIS(ctypes.Structure):
    _fields_ = [
        ("pwszClassName", ctypes.c_void_p),
        ("pwszDescription", ctypes.c_void_p),
        ("celt", wintypes.DWORD),
        ("rgAttributes", ctypes.c_void_p),
    ]

class HypothesisResult(ctypes.Structure):
    _fields_ = [
        ("hypothesis", HYPOTHESIS),
        ("pathStatus", ctypes.c_int),
    ]

#[repr(C)]
pub struct HYPOTHESIS {
    pub pwszClassName: *mut core::ffi::c_void,
    pub pwszDescription: *mut core::ffi::c_void,
    pub celt: u32,
    pub rgAttributes: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct HypothesisResult {
    pub hypothesis: HYPOTHESIS,
    pub pathStatus: i32,
}

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

type HYPOTHESIS struct {
	pwszClassName uintptr
	pwszDescription uintptr
	celt uint32
	rgAttributes uintptr
}

type HypothesisResult struct {
	hypothesis HYPOTHESIS
	pathStatus int32
}

type
  HYPOTHESIS = record
    pwszClassName: Pointer;
    pwszDescription: Pointer;
    celt: DWORD;
    rgAttributes: Pointer;
  end;

  HypothesisResult = record
    hypothesis: HYPOTHESIS;
    pathStatus: Integer;
  end;

const HYPOTHESIS = extern struct {
    pwszClassName: ?*anyopaque,
    pwszDescription: ?*anyopaque,
    celt: u32,
    rgAttributes: ?*anyopaque,
};

const HypothesisResult = extern struct {
    hypothesis: HYPOTHESIS,
    pathStatus: i32,
};

type
  HYPOTHESIS {.bycopy.} = object
    pwszClassName: pointer
    pwszDescription: pointer
    celt: uint32
    rgAttributes: pointer

  HypothesisResult {.bycopy.} = object
    hypothesis: HYPOTHESIS
    pathStatus: int32

struct HYPOTHESIS
{
    void* pwszClassName;
    void* pwszDescription;
    uint celt;
    void* rgAttributes;
}

struct HypothesisResult
{
    HYPOTHESIS hypothesis;
    int pathStatus;
}