USBD_INTERFACE_INFORMATION

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct USBD_PIPE_INFORMATION
{
    public ushort MaximumPacketSize;
    public byte EndpointAddress;
    public byte Interval;
    public int PipeType;
    public IntPtr PipeHandle;
    public uint MaximumTransferSize;
    public uint PipeFlags;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct USBD_INTERFACE_INFORMATION
{
    public ushort Length;
    public byte InterfaceNumber;
    public byte AlternateSetting;
    public byte Class;
    public byte SubClass;
    public byte Protocol;
    public byte Reserved;
    public IntPtr InterfaceHandle;
    public uint NumberOfPipes;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public USBD_PIPE_INFORMATION[] Pipes;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure USBD_PIPE_INFORMATION
    Public MaximumPacketSize As UShort
    Public EndpointAddress As Byte
    Public Interval As Byte
    Public PipeType As Integer
    Public PipeHandle As IntPtr
    Public MaximumTransferSize As UInteger
    Public PipeFlags As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure USBD_INTERFACE_INFORMATION
    Public Length As UShort
    Public InterfaceNumber As Byte
    Public AlternateSetting As Byte
    Public Class As Byte
    Public SubClass As Byte
    Public Protocol As Byte
    Public Reserved As Byte
    Public InterfaceHandle As IntPtr
    Public NumberOfPipes As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Pipes() As USBD_PIPE_INFORMATION
End Structure

import ctypes
from ctypes import wintypes

class USBD_PIPE_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("MaximumPacketSize", ctypes.c_ushort),
        ("EndpointAddress", ctypes.c_ubyte),
        ("Interval", ctypes.c_ubyte),
        ("PipeType", ctypes.c_int),
        ("PipeHandle", ctypes.c_void_p),
        ("MaximumTransferSize", wintypes.DWORD),
        ("PipeFlags", wintypes.DWORD),
    ]

class USBD_INTERFACE_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("Length", ctypes.c_ushort),
        ("InterfaceNumber", ctypes.c_ubyte),
        ("AlternateSetting", ctypes.c_ubyte),
        ("Class", ctypes.c_ubyte),
        ("SubClass", ctypes.c_ubyte),
        ("Protocol", ctypes.c_ubyte),
        ("Reserved", ctypes.c_ubyte),
        ("InterfaceHandle", ctypes.c_void_p),
        ("NumberOfPipes", wintypes.DWORD),
        ("Pipes", USBD_PIPE_INFORMATION * 1),
    ]

#[repr(C)]
pub struct USBD_PIPE_INFORMATION {
    pub MaximumPacketSize: u16,
    pub EndpointAddress: u8,
    pub Interval: u8,
    pub PipeType: i32,
    pub PipeHandle: *mut core::ffi::c_void,
    pub MaximumTransferSize: u32,
    pub PipeFlags: u32,
}

#[repr(C)]
pub struct USBD_INTERFACE_INFORMATION {
    pub Length: u16,
    pub InterfaceNumber: u8,
    pub AlternateSetting: u8,
    pub Class: u8,
    pub SubClass: u8,
    pub Protocol: u8,
    pub Reserved: u8,
    pub InterfaceHandle: *mut core::ffi::c_void,
    pub NumberOfPipes: u32,
    pub Pipes: [USBD_PIPE_INFORMATION; 1],
}

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

type USBD_PIPE_INFORMATION struct {
	MaximumPacketSize uint16
	EndpointAddress byte
	Interval byte
	PipeType int32
	PipeHandle uintptr
	MaximumTransferSize uint32
	PipeFlags uint32
}

type USBD_INTERFACE_INFORMATION struct {
	Length uint16
	InterfaceNumber byte
	AlternateSetting byte
	Class byte
	SubClass byte
	Protocol byte
	Reserved byte
	InterfaceHandle uintptr
	NumberOfPipes uint32
	Pipes [1]USBD_PIPE_INFORMATION
}

type
  USBD_PIPE_INFORMATION = record
    MaximumPacketSize: Word;
    EndpointAddress: Byte;
    Interval: Byte;
    PipeType: Integer;
    PipeHandle: Pointer;
    MaximumTransferSize: DWORD;
    PipeFlags: DWORD;
  end;

  USBD_INTERFACE_INFORMATION = record
    Length: Word;
    InterfaceNumber: Byte;
    AlternateSetting: Byte;
    Class: Byte;
    SubClass: Byte;
    Protocol: Byte;
    Reserved: Byte;
    InterfaceHandle: Pointer;
    NumberOfPipes: DWORD;
    Pipes: array[0..0] of USBD_PIPE_INFORMATION;
  end;

const USBD_PIPE_INFORMATION = extern struct {
    MaximumPacketSize: u16,
    EndpointAddress: u8,
    Interval: u8,
    PipeType: i32,
    PipeHandle: ?*anyopaque,
    MaximumTransferSize: u32,
    PipeFlags: u32,
};

const USBD_INTERFACE_INFORMATION = extern struct {
    Length: u16,
    InterfaceNumber: u8,
    AlternateSetting: u8,
    Class: u8,
    SubClass: u8,
    Protocol: u8,
    Reserved: u8,
    InterfaceHandle: ?*anyopaque,
    NumberOfPipes: u32,
    Pipes: [1]USBD_PIPE_INFORMATION,
};

type
  USBD_PIPE_INFORMATION {.bycopy.} = object
    MaximumPacketSize: uint16
    EndpointAddress: uint8
    Interval: uint8
    PipeType: int32
    PipeHandle: pointer
    MaximumTransferSize: uint32
    PipeFlags: uint32

  USBD_INTERFACE_INFORMATION {.bycopy.} = object
    Length: uint16
    InterfaceNumber: uint8
    AlternateSetting: uint8
    Class: uint8
    SubClass: uint8
    Protocol: uint8
    Reserved: uint8
    InterfaceHandle: pointer
    NumberOfPipes: uint32
    Pipes: array[1, USBD_PIPE_INFORMATION]

struct USBD_PIPE_INFORMATION
{
    ushort MaximumPacketSize;
    ubyte EndpointAddress;
    ubyte Interval;
    int PipeType;
    void* PipeHandle;
    uint MaximumTransferSize;
    uint PipeFlags;
}

struct USBD_INTERFACE_INFORMATION
{
    ushort Length;
    ubyte InterfaceNumber;
    ubyte AlternateSetting;
    ubyte Class;
    ubyte SubClass;
    ubyte Protocol;
    ubyte Reserved;
    void* InterfaceHandle;
    uint NumberOfPipes;
    USBD_PIPE_INFORMATION[1] Pipes;
}