SCANINFO

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RANGEVALUE
{
    public int lMin;
    public int lMax;
    public int lStep;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SCANWINDOW
{
    public int xPos;
    public int yPos;
    public int xExtent;
    public int yExtent;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SCANINFO
{
    public int ADF;
    public int TPA;
    public int Endorser;
    public int OpticalXResolution;
    public int OpticalYResolution;
    public int BedWidth;
    public int BedHeight;
    public RANGEVALUE IntensityRange;
    public RANGEVALUE ContrastRange;
    public int SupportedCompressionType;
    public int SupportedDataTypes;
    public int WidthPixels;
    public int WidthBytes;
    public int Lines;
    public int DataType;
    public int PixelBits;
    public int Intensity;
    public int Contrast;
    public int Xresolution;
    public int Yresolution;
    public SCANWINDOW Window;
    public int DitherPattern;
    public int Negative;
    public int Mirror;
    public int AutoBack;
    public int ColorDitherPattern;
    public int ToneMap;
    public int Compression;
    public int RawDataFormat;
    public int RawPixelOrder;
    public int bNeedDataAlignment;
    public int DelayBetweenRead;
    public int MaxBufferSize;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public IntPtr[] DeviceIOHandles;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public int[] lReserved;
    public IntPtr pMicroDriverContext;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RANGEVALUE
    Public lMin As Integer
    Public lMax As Integer
    Public lStep As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SCANWINDOW
    Public xPos As Integer
    Public yPos As Integer
    Public xExtent As Integer
    Public yExtent As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SCANINFO
    Public ADF As Integer
    Public TPA As Integer
    Public Endorser As Integer
    Public OpticalXResolution As Integer
    Public OpticalYResolution As Integer
    Public BedWidth As Integer
    Public BedHeight As Integer
    Public IntensityRange As RANGEVALUE
    Public ContrastRange As RANGEVALUE
    Public SupportedCompressionType As Integer
    Public SupportedDataTypes As Integer
    Public WidthPixels As Integer
    Public WidthBytes As Integer
    Public Lines As Integer
    Public DataType As Integer
    Public PixelBits As Integer
    Public Intensity As Integer
    Public Contrast As Integer
    Public Xresolution As Integer
    Public Yresolution As Integer
    Public Window As SCANWINDOW
    Public DitherPattern As Integer
    Public Negative As Integer
    Public Mirror As Integer
    Public AutoBack As Integer
    Public ColorDitherPattern As Integer
    Public ToneMap As Integer
    Public Compression As Integer
    Public RawDataFormat As Integer
    Public RawPixelOrder As Integer
    Public bNeedDataAlignment As Integer
    Public DelayBetweenRead As Integer
    Public MaxBufferSize As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public DeviceIOHandles() As IntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Public lReserved() As Integer
    Public pMicroDriverContext As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class RANGEVALUE(ctypes.Structure):
    _fields_ = [
        ("lMin", ctypes.c_int),
        ("lMax", ctypes.c_int),
        ("lStep", ctypes.c_int),
    ]

class SCANWINDOW(ctypes.Structure):
    _fields_ = [
        ("xPos", ctypes.c_int),
        ("yPos", ctypes.c_int),
        ("xExtent", ctypes.c_int),
        ("yExtent", ctypes.c_int),
    ]

class SCANINFO(ctypes.Structure):
    _fields_ = [
        ("ADF", ctypes.c_int),
        ("TPA", ctypes.c_int),
        ("Endorser", ctypes.c_int),
        ("OpticalXResolution", ctypes.c_int),
        ("OpticalYResolution", ctypes.c_int),
        ("BedWidth", ctypes.c_int),
        ("BedHeight", ctypes.c_int),
        ("IntensityRange", RANGEVALUE),
        ("ContrastRange", RANGEVALUE),
        ("SupportedCompressionType", ctypes.c_int),
        ("SupportedDataTypes", ctypes.c_int),
        ("WidthPixels", ctypes.c_int),
        ("WidthBytes", ctypes.c_int),
        ("Lines", ctypes.c_int),
        ("DataType", ctypes.c_int),
        ("PixelBits", ctypes.c_int),
        ("Intensity", ctypes.c_int),
        ("Contrast", ctypes.c_int),
        ("Xresolution", ctypes.c_int),
        ("Yresolution", ctypes.c_int),
        ("Window", SCANWINDOW),
        ("DitherPattern", ctypes.c_int),
        ("Negative", ctypes.c_int),
        ("Mirror", ctypes.c_int),
        ("AutoBack", ctypes.c_int),
        ("ColorDitherPattern", ctypes.c_int),
        ("ToneMap", ctypes.c_int),
        ("Compression", ctypes.c_int),
        ("RawDataFormat", ctypes.c_int),
        ("RawPixelOrder", ctypes.c_int),
        ("bNeedDataAlignment", ctypes.c_int),
        ("DelayBetweenRead", ctypes.c_int),
        ("MaxBufferSize", ctypes.c_int),
        ("DeviceIOHandles", ctypes.c_void_p * 16),
        ("lReserved", ctypes.c_int * 4),
        ("pMicroDriverContext", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct RANGEVALUE {
    pub lMin: i32,
    pub lMax: i32,
    pub lStep: i32,
}

#[repr(C)]
pub struct SCANWINDOW {
    pub xPos: i32,
    pub yPos: i32,
    pub xExtent: i32,
    pub yExtent: i32,
}

#[repr(C)]
pub struct SCANINFO {
    pub ADF: i32,
    pub TPA: i32,
    pub Endorser: i32,
    pub OpticalXResolution: i32,
    pub OpticalYResolution: i32,
    pub BedWidth: i32,
    pub BedHeight: i32,
    pub IntensityRange: RANGEVALUE,
    pub ContrastRange: RANGEVALUE,
    pub SupportedCompressionType: i32,
    pub SupportedDataTypes: i32,
    pub WidthPixels: i32,
    pub WidthBytes: i32,
    pub Lines: i32,
    pub DataType: i32,
    pub PixelBits: i32,
    pub Intensity: i32,
    pub Contrast: i32,
    pub Xresolution: i32,
    pub Yresolution: i32,
    pub Window: SCANWINDOW,
    pub DitherPattern: i32,
    pub Negative: i32,
    pub Mirror: i32,
    pub AutoBack: i32,
    pub ColorDitherPattern: i32,
    pub ToneMap: i32,
    pub Compression: i32,
    pub RawDataFormat: i32,
    pub RawPixelOrder: i32,
    pub bNeedDataAlignment: i32,
    pub DelayBetweenRead: i32,
    pub MaxBufferSize: i32,
    pub DeviceIOHandles: [*mut core::ffi::c_void; 16],
    pub lReserved: [i32; 4],
    pub pMicroDriverContext: *mut core::ffi::c_void,
}

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

type RANGEVALUE struct {
	lMin int32
	lMax int32
	lStep int32
}

type SCANWINDOW struct {
	xPos int32
	yPos int32
	xExtent int32
	yExtent int32
}

type SCANINFO struct {
	ADF int32
	TPA int32
	Endorser int32
	OpticalXResolution int32
	OpticalYResolution int32
	BedWidth int32
	BedHeight int32
	IntensityRange RANGEVALUE
	ContrastRange RANGEVALUE
	SupportedCompressionType int32
	SupportedDataTypes int32
	WidthPixels int32
	WidthBytes int32
	Lines int32
	DataType int32
	PixelBits int32
	Intensity int32
	Contrast int32
	Xresolution int32
	Yresolution int32
	Window SCANWINDOW
	DitherPattern int32
	Negative int32
	Mirror int32
	AutoBack int32
	ColorDitherPattern int32
	ToneMap int32
	Compression int32
	RawDataFormat int32
	RawPixelOrder int32
	bNeedDataAlignment int32
	DelayBetweenRead int32
	MaxBufferSize int32
	DeviceIOHandles [16]uintptr
	lReserved [4]int32
	pMicroDriverContext uintptr
}

type
  RANGEVALUE = record
    lMin: Integer;
    lMax: Integer;
    lStep: Integer;
  end;

  SCANWINDOW = record
    xPos: Integer;
    yPos: Integer;
    xExtent: Integer;
    yExtent: Integer;
  end;

  SCANINFO = record
    ADF: Integer;
    TPA: Integer;
    Endorser: Integer;
    OpticalXResolution: Integer;
    OpticalYResolution: Integer;
    BedWidth: Integer;
    BedHeight: Integer;
    IntensityRange: RANGEVALUE;
    ContrastRange: RANGEVALUE;
    SupportedCompressionType: Integer;
    SupportedDataTypes: Integer;
    WidthPixels: Integer;
    WidthBytes: Integer;
    Lines: Integer;
    DataType: Integer;
    PixelBits: Integer;
    Intensity: Integer;
    Contrast: Integer;
    Xresolution: Integer;
    Yresolution: Integer;
    Window: SCANWINDOW;
    DitherPattern: Integer;
    Negative: Integer;
    Mirror: Integer;
    AutoBack: Integer;
    ColorDitherPattern: Integer;
    ToneMap: Integer;
    Compression: Integer;
    RawDataFormat: Integer;
    RawPixelOrder: Integer;
    bNeedDataAlignment: Integer;
    DelayBetweenRead: Integer;
    MaxBufferSize: Integer;
    DeviceIOHandles: array[0..15] of Pointer;
    lReserved: array[0..3] of Integer;
    pMicroDriverContext: Pointer;
  end;

const RANGEVALUE = extern struct {
    lMin: i32,
    lMax: i32,
    lStep: i32,
};

const SCANWINDOW = extern struct {
    xPos: i32,
    yPos: i32,
    xExtent: i32,
    yExtent: i32,
};

const SCANINFO = extern struct {
    ADF: i32,
    TPA: i32,
    Endorser: i32,
    OpticalXResolution: i32,
    OpticalYResolution: i32,
    BedWidth: i32,
    BedHeight: i32,
    IntensityRange: RANGEVALUE,
    ContrastRange: RANGEVALUE,
    SupportedCompressionType: i32,
    SupportedDataTypes: i32,
    WidthPixels: i32,
    WidthBytes: i32,
    Lines: i32,
    DataType: i32,
    PixelBits: i32,
    Intensity: i32,
    Contrast: i32,
    Xresolution: i32,
    Yresolution: i32,
    Window: SCANWINDOW,
    DitherPattern: i32,
    Negative: i32,
    Mirror: i32,
    AutoBack: i32,
    ColorDitherPattern: i32,
    ToneMap: i32,
    Compression: i32,
    RawDataFormat: i32,
    RawPixelOrder: i32,
    bNeedDataAlignment: i32,
    DelayBetweenRead: i32,
    MaxBufferSize: i32,
    DeviceIOHandles: [16]?*anyopaque,
    lReserved: [4]i32,
    pMicroDriverContext: ?*anyopaque,
};

type
  RANGEVALUE {.bycopy.} = object
    lMin: int32
    lMax: int32
    lStep: int32

  SCANWINDOW {.bycopy.} = object
    xPos: int32
    yPos: int32
    xExtent: int32
    yExtent: int32

  SCANINFO {.bycopy.} = object
    ADF: int32
    TPA: int32
    Endorser: int32
    OpticalXResolution: int32
    OpticalYResolution: int32
    BedWidth: int32
    BedHeight: int32
    IntensityRange: RANGEVALUE
    ContrastRange: RANGEVALUE
    SupportedCompressionType: int32
    SupportedDataTypes: int32
    WidthPixels: int32
    WidthBytes: int32
    Lines: int32
    DataType: int32
    PixelBits: int32
    Intensity: int32
    Contrast: int32
    Xresolution: int32
    Yresolution: int32
    Window: SCANWINDOW
    DitherPattern: int32
    Negative: int32
    Mirror: int32
    AutoBack: int32
    ColorDitherPattern: int32
    ToneMap: int32
    Compression: int32
    RawDataFormat: int32
    RawPixelOrder: int32
    bNeedDataAlignment: int32
    DelayBetweenRead: int32
    MaxBufferSize: int32
    DeviceIOHandles: array[16, pointer]
    lReserved: array[4, int32]
    pMicroDriverContext: pointer

struct RANGEVALUE
{
    int lMin;
    int lMax;
    int lStep;
}

struct SCANWINDOW
{
    int xPos;
    int yPos;
    int xExtent;
    int yExtent;
}

struct SCANINFO
{
    int ADF;
    int TPA;
    int Endorser;
    int OpticalXResolution;
    int OpticalYResolution;
    int BedWidth;
    int BedHeight;
    RANGEVALUE IntensityRange;
    RANGEVALUE ContrastRange;
    int SupportedCompressionType;
    int SupportedDataTypes;
    int WidthPixels;
    int WidthBytes;
    int Lines;
    int DataType;
    int PixelBits;
    int Intensity;
    int Contrast;
    int Xresolution;
    int Yresolution;
    SCANWINDOW Window;
    int DitherPattern;
    int Negative;
    int Mirror;
    int AutoBack;
    int ColorDitherPattern;
    int ToneMap;
    int Compression;
    int RawDataFormat;
    int RawPixelOrder;
    int bNeedDataAlignment;
    int DelayBetweenRead;
    int MaxBufferSize;
    void*[16] DeviceIOHandles;
    int[4] lReserved;
    void* pMicroDriverContext;
}