DELTA_HEADER_INFO

using System;
using System.Runtime.InteropServices;

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

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DELTA_HASH
{
    public uint HashSize;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] HashValue;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DELTA_HEADER_INFO
{
    public long FileTypeSet;
    public long FileType;
    public long Flags;
    public UIntPtr TargetSize;
    public FILETIME TargetFileTime;
    public uint TargetHashAlgId;
    public DELTA_HASH TargetHash;
}

Imports System.Runtime.InteropServices

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

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DELTA_HASH
    Public HashSize As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public HashValue() As Byte
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DELTA_HEADER_INFO
    Public FileTypeSet As Long
    Public FileType As Long
    Public Flags As Long
    Public TargetSize As UIntPtr
    Public TargetFileTime As FILETIME
    Public TargetHashAlgId As UInteger
    Public TargetHash As DELTA_HASH
End Structure

import ctypes
from ctypes import wintypes

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

class DELTA_HASH(ctypes.Structure):
    _fields_ = [
        ("HashSize", wintypes.DWORD),
        ("HashValue", ctypes.c_ubyte * 32),
    ]

class DELTA_HEADER_INFO(ctypes.Structure):
    _fields_ = [
        ("FileTypeSet", ctypes.c_longlong),
        ("FileType", ctypes.c_longlong),
        ("Flags", ctypes.c_longlong),
        ("TargetSize", ctypes.c_size_t),
        ("TargetFileTime", FILETIME),
        ("TargetHashAlgId", wintypes.DWORD),
        ("TargetHash", DELTA_HASH),
    ]

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

#[repr(C)]
pub struct DELTA_HASH {
    pub HashSize: u32,
    pub HashValue: [u8; 32],
}

#[repr(C)]
pub struct DELTA_HEADER_INFO {
    pub FileTypeSet: i64,
    pub FileType: i64,
    pub Flags: i64,
    pub TargetSize: usize,
    pub TargetFileTime: FILETIME,
    pub TargetHashAlgId: u32,
    pub TargetHash: DELTA_HASH,
}

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

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type DELTA_HASH struct {
	HashSize uint32
	HashValue [32]byte
}

type DELTA_HEADER_INFO struct {
	FileTypeSet int64
	FileType int64
	Flags int64
	TargetSize uintptr
	TargetFileTime FILETIME
	TargetHashAlgId uint32
	TargetHash DELTA_HASH
}

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

  DELTA_HASH = record
    HashSize: DWORD;
    HashValue: array[0..31] of Byte;
  end;

  DELTA_HEADER_INFO = record
    FileTypeSet: Int64;
    FileType: Int64;
    Flags: Int64;
    TargetSize: NativeUInt;
    TargetFileTime: FILETIME;
    TargetHashAlgId: DWORD;
    TargetHash: DELTA_HASH;
  end;

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

const DELTA_HASH = extern struct {
    HashSize: u32,
    HashValue: [32]u8,
};

const DELTA_HEADER_INFO = extern struct {
    FileTypeSet: i64,
    FileType: i64,
    Flags: i64,
    TargetSize: usize,
    TargetFileTime: FILETIME,
    TargetHashAlgId: u32,
    TargetHash: DELTA_HASH,
};

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

  DELTA_HASH {.bycopy.} = object
    HashSize: uint32
    HashValue: array[32, uint8]

  DELTA_HEADER_INFO {.bycopy.} = object
    FileTypeSet: int64
    FileType: int64
    Flags: int64
    TargetSize: uint
    TargetFileTime: FILETIME
    TargetHashAlgId: uint32
    TargetHash: DELTA_HASH

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct DELTA_HASH
{
    uint HashSize;
    ubyte[32] HashValue;
}

struct DELTA_HEADER_INFO
{
    long FileTypeSet;
    long FileType;
    long Flags;
    size_t TargetSize;
    FILETIME TargetFileTime;
    uint TargetHashAlgId;
    DELTA_HASH TargetHash;
}