_URB_SELECT_CONFIGURATION

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _URB_HEADER
{
    public ushort Length;
    public ushort Function;
    public int Status;
    public IntPtr UsbdDeviceHandle;
    public uint UsbdFlags;
}

[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;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct _URB_SELECT_CONFIGURATION
{
    public _URB_HEADER Hdr;
    public IntPtr ConfigurationDescriptor;
    public IntPtr ConfigurationHandle;
    public USBD_INTERFACE_INFORMATION Interface;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure _URB_HEADER
    Public Length As UShort
    Public Function As UShort
    Public Status As Integer
    Public UsbdDeviceHandle As IntPtr
    Public UsbdFlags As UInteger
End Structure

<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

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure _URB_SELECT_CONFIGURATION
    Public Hdr As _URB_HEADER
    Public ConfigurationDescriptor As IntPtr
    Public ConfigurationHandle As IntPtr
    Public Interface As USBD_INTERFACE_INFORMATION
End Structure

import ctypes
from ctypes import wintypes

class _URB_HEADER(ctypes.Structure):
    _fields_ = [
        ("Length", ctypes.c_ushort),
        ("Function", ctypes.c_ushort),
        ("Status", ctypes.c_int),
        ("UsbdDeviceHandle", ctypes.c_void_p),
        ("UsbdFlags", wintypes.DWORD),
    ]

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),
    ]

class _URB_SELECT_CONFIGURATION(ctypes.Structure):
    _fields_ = [
        ("Hdr", _URB_HEADER),
        ("ConfigurationDescriptor", ctypes.c_void_p),
        ("ConfigurationHandle", ctypes.c_void_p),
        ("Interface", USBD_INTERFACE_INFORMATION),
    ]

#[repr(C)]
pub struct _URB_HEADER {
    pub Length: u16,
    pub Function: u16,
    pub Status: i32,
    pub UsbdDeviceHandle: *mut core::ffi::c_void,
    pub UsbdFlags: u32,
}

#[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],
}

#[repr(C)]
pub struct _URB_SELECT_CONFIGURATION {
    pub Hdr: _URB_HEADER,
    pub ConfigurationDescriptor: *mut core::ffi::c_void,
    pub ConfigurationHandle: *mut core::ffi::c_void,
    pub Interface: USBD_INTERFACE_INFORMATION,
}

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

type _URB_HEADER struct {
	Length uint16
	Function uint16
	Status int32
	UsbdDeviceHandle uintptr
	UsbdFlags uint32
}

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 _URB_SELECT_CONFIGURATION struct {
	Hdr _URB_HEADER
	ConfigurationDescriptor uintptr
	ConfigurationHandle uintptr
	Interface USBD_INTERFACE_INFORMATION
}

type
  _URB_HEADER = record
    Length: Word;
    Function: Word;
    Status: Integer;
    UsbdDeviceHandle: Pointer;
    UsbdFlags: DWORD;
  end;

  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;

  _URB_SELECT_CONFIGURATION = record
    Hdr: _URB_HEADER;
    ConfigurationDescriptor: Pointer;
    ConfigurationHandle: Pointer;
    Interface: USBD_INTERFACE_INFORMATION;
  end;

const _URB_HEADER = extern struct {
    Length: u16,
    Function: u16,
    Status: i32,
    UsbdDeviceHandle: ?*anyopaque,
    UsbdFlags: u32,
};

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,
};

const _URB_SELECT_CONFIGURATION = extern struct {
    Hdr: _URB_HEADER,
    ConfigurationDescriptor: ?*anyopaque,
    ConfigurationHandle: ?*anyopaque,
    Interface: USBD_INTERFACE_INFORMATION,
};

type
  _URB_HEADER {.bycopy.} = object
    Length: uint16
    Function: uint16
    Status: int32
    UsbdDeviceHandle: pointer
    UsbdFlags: uint32

  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]

  _URB_SELECT_CONFIGURATION {.bycopy.} = object
    Hdr: _URB_HEADER
    ConfigurationDescriptor: pointer
    ConfigurationHandle: pointer
    Interface: USBD_INTERFACE_INFORMATION

struct _URB_HEADER
{
    ushort Length;
    ushort Function;
    int Status;
    void* UsbdDeviceHandle;
    uint UsbdFlags;
}

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;
}

struct _URB_SELECT_CONFIGURATION
{
    _URB_HEADER Hdr;
    void* ConfigurationDescriptor;
    void* ConfigurationHandle;
    USBD_INTERFACE_INFORMATION Interface;
}