libusbK.cs

#region Copyright (c) Travis Robinson

// Copyright (c) 2011-2021 Travis Robinson <libusbdotnet@gmail.com>
// All rights reserved.
//
// C# libusbK Bindings
// Auto-generated on: 07.08.2021
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TRAVIS LEE ROBINSON
// BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.

#endregion

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

// ReSharper disable InconsistentNaming
// ReSharper disable CheckNamespace
// ReSharper disable UnassignedReadonlyField

namespace libusbK
{
    public static class AllKOptions
    {
        /// <summary>
        ///     Alternate libusbK library to use.  This must be assigned before any libusbK functions are called and it must be the
        ///     full path and file name to a libusbK.dll.
        /// </summary>
        public static string LIBUSBK_FULLPATH_TO_ALTERNATE_DLL;
    }

    public static class AllKConstants
    {
        /// <summary>
        ///     Allocated length for all strings in a \ref KLST_DEVINFO structure.
        /// </summary>
        public const int KLST_STRING_MAX_LEN = 256;

        /// <summary>
        ///     libusbK library
        /// </summary>
        public const string LIBUSBK_DLL = "libusbK.dll";

        /// <summary>
        ///     Config power mask for the \c bmAttributes field of a \ref USB_CONFIGURATION_DESCRIPTOR
        /// </summary>
        public const byte USB_CONFIG_POWERED_MASK = 0xC0;

        /// <summary>
        ///     Endpoint direction mask for the \c bEndpointAddress field of a \ref USB_ENDPOINT_DESCRIPTOR
        /// </summary>
        public const byte USB_ENDPOINT_DIRECTION_MASK = 0x80;

        /// <summary>
        ///     Endpoint address mask for the \c bEndpointAddress field of a \ref USB_ENDPOINT_DESCRIPTOR
        /// </summary>
        public const byte USB_ENDPOINT_ADDRESS_MASK = 0x0F;
    }

    public enum PipePolicyType
    {
        SHORT_PACKET_TERMINATE = 0x01,
        AUTO_CLEAR_STALL = 0x02,
        PIPE_TRANSFER_TIMEOUT = 0x03,
        IGNORE_SHORT_PACKETS = 0x04,
        ALLOW_PARTIAL_READS = 0x05,
        AUTO_FLUSH = 0x06,
        RAW_IO = 0x07,
        MAXIMUM_TRANSFER_SIZE = 0x08,
        RESET_PIPE_ON_RESUME = 0x09,

        ISO_START_LATENCY = 0x20,
        ISO_ALWAYS_START_ASAP = 0x21,
        ISO_NUM_FIXED_PACKETS = 0x22,

        SIMUL_PARALLEL_REQUESTS = 0x30,
    }

    public enum PowerPolicyType
    {
        AUTO_SUSPEND = 0x81,
        SUSPEND_DELAY = 0x83,
    }

    public enum DeviceInformationType
    {
        DEVICE_SPEED = 0x01,
    }

    public enum EndpointType
    {
        /// <summary>
        ///     Indicates a control endpoint
        /// </summary>
        CONTROL = 0x00,

        /// <summary>
        ///     Indicates an isochronous endpoint
        /// </summary>
        ISOCHRONOUS = 0x01,

        /// <summary>
        ///     Indicates a bulk endpoint
        /// </summary>
        BULK = 0x02,

        /// <summary>
        ///     Indicates an interrupt endpoint
        /// </summary>
        INTERRUPT = 0x03,

        /// <summary>
        ///     Endpoint type mask for the \c bmAttributes field of a \ref USB_ENDPOINT_DESCRIPTOR
        /// </summary>
        MASK = 0x03,
    }

    public static class ErrorCodes
    {
        /// <summary>
        ///     The operation completed successfully.
        /// </summary>
        public const int Success = 0;

        /// <summary>
        ///     Access is denied.
        /// </summary>
        public const int AccessDenied = 5;

        /// <summary>
        ///     The handle is invalid.
        /// </summary>
        public const int InvalidHandle = 6;

        /// <summary>
        ///     Not enough storage is available to process this command.
        /// </summary>
        public const int NotEnoughMemory = 8;

        /// <summary>
        ///     The request is not supported.
        /// </summary>
        public const int NotSupported = 50;

        /// <summary>
        ///     The parameter is incorrect.
        /// </summary>
        public const int InvalidParameter = 87;

        /// <summary>
        ///     The semaphore timeout period has expired.
        /// </summary>
        public const int SemTimeout = 121;

        /// <summary>
        ///     The requested resource is in use.
        /// </summary>
        public const int Busy = 170;

        /// <summary>
        ///     Too many dynamic-link modules are attached to this program or dynamic-link module.
        /// </summary>
        public const int TooManyModules = 214;

        /// <summary>
        ///     More data is available.
        /// </summary>
        public const int MoreData = 234;

        /// <summary>
        ///     No more data is available.
        /// </summary>
        public const int NoMoreItems = 259;

        /// <summary>
        ///     An attempt was made to operate on a thread within a specific process, but the thread specified is not in the
        ///     process specified.
        /// </summary>
        public const int ThreadNotInProcess = 566;

        /// <summary>
        ///     A thread termination occurred while the thread was suspended. The thread was resumed, and termination proceeded.
        /// </summary>
        public const int ThreadWasSuspended = 699;

        /// <summary>
        ///     The I/O operation has been aborted because of either a thread exit or an application request.
        /// </summary>
        public const int OperationAborted = 995;

        /// <summary>
        ///     Overlapped I/O event is not in a signaled state.
        /// </summary>
        public const int IoIncomplete = 996;

        /// <summary>
        ///     Overlapped I/O operation is in progress.
        /// </summary>
        public const int IoPending = 997;

        /// <summary>
        ///     Element not found.
        /// </summary>
        public const int NotFound = 1168;

        /// <summary>
        ///     The operation was canceled by the user.
        /// </summary>
        public const int Cancelled = 1223;

        /// <summary>
        ///     The library, drive, or media pool is empty.
        /// </summary>
        public const int Empty = 4306;

        /// <summary>
        ///     The cluster resource is not available.
        /// </summary>
        public const int ResourceNotAvailable = 5006;

        /// <summary>
        ///     The cluster resource could not be found.
        /// </summary>
        public const int ResourceNotFound = 5007;
    }

    public interface IKLIB_HANDLE
    {
        KLIB_HANDLE_TYPE HandleType { get; }

        IntPtr Pointer { get; }

        IntPtr GetContext();
        bool SetContext(IntPtr UserContext);
        bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback);
    }

    /// <Summary>
    ///     A structure representing additional information about super speed (or higher) endpoints.
    /// </Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Specifies the maximum number of packets that the endpoint can send or receive as a part of a burst.</Summary>
        public byte bMaxBurst;

        public byte AsUchar;

        /// <Summary>Number of bytes per interval</Summary>
        public ushort wBytesPerInterval;

        /// <Summary>Specifies the maximum number of streams supported by the bulk endpoint.</Summary>
        public byte BulkMaxStreams
        {
            get { return (byte) (AsUchar & 0x1F); }
        }

        /// <Summary>
        ///     Specifies a zero-based number that determines the maximum number of packets (bMaxBurst * (Mult + 1)) that can
        ///     be sent to the endpoint within a service interval.
        /// </Summary>
        public byte IsoMult
        {
            get { return (byte) (AsUchar & 0x3); }
        }

        public byte SspCompanion
        {
            get { return (byte) (AsUchar >> 7); }
        }
    }

    #region Opaque library handles

    public struct KLST_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KLST_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.LSTK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    public struct KHOT_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KHOT_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.HOTK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    public struct KUSB_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KUSB_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.USBK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }

        #region USB Shared Device Context

        public IntPtr GetSharedContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, KLIB_HANDLE_TYPE.USBSHAREDK);
        }

        public bool SetSharedContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, KLIB_HANDLE_TYPE.USBSHAREDK, UserContext);
        }

        public bool SetSharedCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, KLIB_HANDLE_TYPE.USBSHAREDK, CleanupCallback);
        }

        #endregion
    }

    public struct KOVL_POOL_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KOVL_POOL_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.OVLPOOLK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    public struct KOVL_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KOVL_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.OVLK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    public struct KSTM_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KSTM_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.STMK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    public struct KISOCH_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KISOCH_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.ISOCHK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }
    }

    #endregion

    #region Internal Function Imports

    internal static class AllKFunctions
    {
        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate void HotK_FreeAllDelegate();

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool HotK_FreeDelegate([In] KHOT_HANDLE Handle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool HotK_InitDelegate([Out] out KHOT_HANDLE Handle, [In] [Out] ref KHOT_PARAMS InitParams);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_CalcPacketInformationDelegate(bool IsHighSpeed, [In] ref WINUSB_PIPE_INFORMATION_EX PipeInformationEx, [Out] out KISOCH_PACKET_INFORMATION PacketInformation);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_EnumPacketsDelegate([In] KISOCH_HANDLE IsochHandle, KISOCH_ENUM_PACKETS_CB EnumPackets, uint StartPacketIndex, IntPtr UserState);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_FreeDelegate([In] KISOCH_HANDLE IsochHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_GetNumberOfPacketsDelegate([In] KISOCH_HANDLE IsochHandle, out uint NumberOfPackets);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_GetPacketDelegate([In] KISOCH_HANDLE IsochHandle, uint PacketIndex, out uint Offset, out uint Length, out uint Status);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_InitDelegate([Out] out KISOCH_HANDLE IsochHandle, [In] KUSB_HANDLE InterfaceHandle, byte PipeId, uint MaxNumberOfPackets, IntPtr TransferBuffer, uint TransferBufferSize);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_SetNumberOfPacketsDelegate([In] KISOCH_HANDLE IsochHandle, uint NumberOfPackets);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_SetPacketDelegate([In] KISOCH_HANDLE IsochHandle, uint PacketIndex, uint Offset, uint Length, uint Status);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsochK_SetPacketOffsetsDelegate([In] KISOCH_HANDLE IsochHandle, uint PacketSize);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_EnumPacketsDelegate([In] KISO_CONTEXT IsoContext, KISO_ENUM_PACKETS_CB EnumPackets, int StartPacketIndex, IntPtr UserState);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_FreeDelegate([In] KISO_CONTEXT IsoContext);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_GetPacketDelegate([In] KISO_CONTEXT IsoContext, int PacketIndex, [Out] out KISO_PACKET IsoPacket);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_InitDelegate([Out] out KISO_CONTEXT IsoContext, int NumberOfPackets, int StartFrame);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_ReUseDelegate([In] KISO_CONTEXT IsoContext);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_SetPacketDelegate([In] KISO_CONTEXT IsoContext, int PacketIndex, [In] ref KISO_PACKET IsoPacket);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool IsoK_SetPacketsDelegate([In] KISO_CONTEXT IsoContext, int PacketSize);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate void LibK_Context_FreeDelegate();

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_Context_InitDelegate(IntPtr Heap, IntPtr Reserved);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_CopyDriverAPIDelegate([Out] out KUSB_DRIVER_API DriverAPI, [In] KUSB_HANDLE UsbHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate IntPtr LibK_GetContextDelegate([In] IntPtr Handle, KLIB_HANDLE_TYPE HandleType);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate IntPtr LibK_GetDefaultContextDelegate(KLIB_HANDLE_TYPE HandleType);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_GetProcAddressDelegate(IntPtr ProcAddress, int DriverID, int FunctionID);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate void LibK_GetVersionDelegate([Out] out KLIB_VERSION Version);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_IsFunctionSupportedDelegate([In] ref KUSB_DRIVER_API DriverAPI, uint FunctionID);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_LoadDriverAPIDelegate([Out] out KUSB_DRIVER_API DriverAPI, int DriverID);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_SetCleanupCallbackDelegate([In] IntPtr Handle, KLIB_HANDLE_TYPE HandleType, KLIB_HANDLE_CLEANUP_CB CleanupCB);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_SetContextDelegate([In] IntPtr Handle, KLIB_HANDLE_TYPE HandleType, IntPtr ContextValue);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LibK_SetDefaultContextDelegate(KLIB_HANDLE_TYPE HandleType, IntPtr ContextValue);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_CountDelegate([In] KLST_HANDLE DeviceList, ref uint Count);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_CurrentDelegate([In] KLST_HANDLE DeviceList, [Out] out KLST_DEVINFO_HANDLE DeviceInfo);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_EnumerateDelegate([In] KLST_HANDLE DeviceList, KLST_ENUM_DEVINFO_CB EnumDevListCB, IntPtr Context);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_FindByVidPidDelegate([In] KLST_HANDLE DeviceList, int Vid, int Pid, [Out] out KLST_DEVINFO_HANDLE DeviceInfo);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_FreeDelegate([In] KLST_HANDLE DeviceList);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_InitDelegate([Out] out KLST_HANDLE DeviceList, KLST_FLAG Flags);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_InitExDelegate([Out] out KLST_HANDLE DeviceList, KLST_FLAG Flags, [In] ref KLST_PATTERN_MATCH PatternMatch);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LstK_MoveNextDelegate([In] KLST_HANDLE DeviceList, [Out] out KLST_DEVINFO_HANDLE DeviceInfo);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate void LstK_MoveResetDelegate([In] KLST_HANDLE DeviceList);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LUsb0_ControlTransferDelegate([In] KUSB_HANDLE InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool LUsb0_SetConfigurationDelegate([In] KUSB_HANDLE InterfaceHandle, byte ConfigurationNumber);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_AcquireDelegate([Out] out KOVL_HANDLE OverlappedK, [In] KOVL_POOL_HANDLE PoolHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_FreeDelegate([In] KOVL_POOL_HANDLE PoolHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate IntPtr OvlK_GetEventHandleDelegate([In] KOVL_HANDLE OverlappedK);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_InitDelegate([Out] out KOVL_POOL_HANDLE PoolHandle, [In] KUSB_HANDLE UsbHandle, int MaxOverlappedCount, KOVL_POOL_FLAG Flags);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_IsCompleteDelegate([In] KOVL_HANDLE OverlappedK);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_ReleaseDelegate([In] KOVL_HANDLE OverlappedK);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_ReUseDelegate([In] KOVL_HANDLE OverlappedK);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_WaitAndReleaseDelegate([In] KOVL_HANDLE OverlappedK, int TimeoutMS, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_WaitDelegate([In] KOVL_HANDLE OverlappedK, int TimeoutMS, KOVL_WAIT_FLAG WaitFlags, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_WaitOldestDelegate([In] KOVL_POOL_HANDLE PoolHandle, [Out] out KOVL_HANDLE OverlappedK, int TimeoutMS, KOVL_WAIT_FLAG WaitFlags, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool OvlK_WaitOrCancelDelegate([In] KOVL_HANDLE OverlappedK, int TimeoutMS, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_FreeDelegate([In] KSTM_HANDLE StreamHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_InitDelegate([Out] out KSTM_HANDLE StreamHandle, [In] KUSB_HANDLE UsbHandle, byte PipeID, int MaxTransferSize, int MaxPendingTransfers, int MaxPendingIO, [In] ref KSTM_CALLBACK Callbacks, KSTM_FLAG Flags);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_ReadDelegate([In] KSTM_HANDLE StreamHandle, IntPtr Buffer, int Offset, int Length, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_StartDelegate([In] KSTM_HANDLE StreamHandle);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_StopDelegate([In] KSTM_HANDLE StreamHandle, int TimeoutCancelMS);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool StmK_WriteDelegate([In] KSTM_HANDLE StreamHandle, IntPtr Buffer, int Offset, int Length, out uint TransferredLength);

        [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
        public delegate bool UsbK_FreeDelegate([In] KUSB_HANDLE InterfaceHandle);

        private static readonly IntPtr mModuleLibusbK = IntPtr.Zero;
        public static LibK_GetVersionDelegate LibK_GetVersion;
        public static LibK_GetContextDelegate LibK_GetContext;
        public static LibK_SetContextDelegate LibK_SetContext;
        public static LibK_SetCleanupCallbackDelegate LibK_SetCleanupCallback;
        public static LibK_LoadDriverAPIDelegate LibK_LoadDriverAPI;
        public static LibK_IsFunctionSupportedDelegate LibK_IsFunctionSupported;
        public static LibK_CopyDriverAPIDelegate LibK_CopyDriverAPI;
        public static LibK_GetProcAddressDelegate LibK_GetProcAddress;
        public static LibK_SetDefaultContextDelegate LibK_SetDefaultContext;
        public static LibK_GetDefaultContextDelegate LibK_GetDefaultContext;
        public static LibK_Context_InitDelegate LibK_Context_Init;
        public static LibK_Context_FreeDelegate LibK_Context_Free;
        public static UsbK_FreeDelegate UsbK_Free;
        public static LstK_InitDelegate LstK_Init;
        public static LstK_InitExDelegate LstK_InitEx;
        public static LstK_FreeDelegate LstK_Free;
        public static LstK_EnumerateDelegate LstK_Enumerate;
        public static LstK_CurrentDelegate LstK_Current;
        public static LstK_MoveNextDelegate LstK_MoveNext;
        public static LstK_MoveResetDelegate LstK_MoveReset;
        public static LstK_FindByVidPidDelegate LstK_FindByVidPid;
        public static LstK_CountDelegate LstK_Count;
        public static HotK_InitDelegate HotK_Init;
        public static HotK_FreeDelegate HotK_Free;
        public static HotK_FreeAllDelegate HotK_FreeAll;
        public static OvlK_AcquireDelegate OvlK_Acquire;
        public static OvlK_ReleaseDelegate OvlK_Release;
        public static OvlK_InitDelegate OvlK_Init;
        public static OvlK_FreeDelegate OvlK_Free;
        public static OvlK_GetEventHandleDelegate OvlK_GetEventHandle;
        public static OvlK_WaitDelegate OvlK_Wait;
        public static OvlK_WaitOldestDelegate OvlK_WaitOldest;
        public static OvlK_WaitOrCancelDelegate OvlK_WaitOrCancel;
        public static OvlK_WaitAndReleaseDelegate OvlK_WaitAndRelease;
        public static OvlK_IsCompleteDelegate OvlK_IsComplete;
        public static OvlK_ReUseDelegate OvlK_ReUse;
        public static StmK_InitDelegate StmK_Init;
        public static StmK_FreeDelegate StmK_Free;
        public static StmK_StartDelegate StmK_Start;
        public static StmK_StopDelegate StmK_Stop;
        public static StmK_ReadDelegate StmK_Read;
        public static StmK_WriteDelegate StmK_Write;
        public static IsoK_InitDelegate IsoK_Init;
        public static IsoK_FreeDelegate IsoK_Free;
        public static IsoK_SetPacketsDelegate IsoK_SetPackets;
        public static IsoK_SetPacketDelegate IsoK_SetPacket;
        public static IsoK_GetPacketDelegate IsoK_GetPacket;
        public static IsoK_EnumPacketsDelegate IsoK_EnumPackets;
        public static IsoK_ReUseDelegate IsoK_ReUse;
        public static IsochK_InitDelegate IsochK_Init;
        public static IsochK_FreeDelegate IsochK_Free;
        public static IsochK_SetPacketOffsetsDelegate IsochK_SetPacketOffsets;
        public static IsochK_SetPacketDelegate IsochK_SetPacket;
        public static IsochK_GetPacketDelegate IsochK_GetPacket;
        public static IsochK_EnumPacketsDelegate IsochK_EnumPackets;
        public static IsochK_CalcPacketInformationDelegate IsochK_CalcPacketInformation;
        public static IsochK_GetNumberOfPacketsDelegate IsochK_GetNumberOfPackets;
        public static IsochK_SetNumberOfPacketsDelegate IsochK_SetNumberOfPackets;
        public static LUsb0_ControlTransferDelegate LUsb0_ControlTransfer;
        public static LUsb0_SetConfigurationDelegate LUsb0_SetConfiguration;

        static AllKFunctions()
        {
            if (string.IsNullOrEmpty(AllKOptions.LIBUSBK_FULLPATH_TO_ALTERNATE_DLL))
                mModuleLibusbK = LoadLibraryEx(AllKConstants.LIBUSBK_DLL, IntPtr.Zero, LoadLibraryFlags.NONE);

            else
                mModuleLibusbK = LoadLibraryEx(AllKOptions.LIBUSBK_FULLPATH_TO_ALTERNATE_DLL, IntPtr.Zero, LoadLibraryFlags.LOAD_WITH_ALTERED_SEARCH_PATH);

            if (mModuleLibusbK == IntPtr.Zero)
                throw new DllNotFoundException("libusbK.dll not found.  Please install drivers/applications and retry.");

            LoadDynamicFunctions();
        }

        [DllImport("kernel32.dll")]
        private static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hReservedNull, LoadLibraryFlags dwFlags);

        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
        private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

        private static void LoadDynamicFunctions()
        {
            LibK_GetVersion = (LibK_GetVersionDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_GetVersion"), typeof(LibK_GetVersionDelegate));
            LibK_GetContext = (LibK_GetContextDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_GetContext"), typeof(LibK_GetContextDelegate));
            LibK_SetContext = (LibK_SetContextDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_SetContext"), typeof(LibK_SetContextDelegate));
            LibK_SetCleanupCallback = (LibK_SetCleanupCallbackDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_SetCleanupCallback"), typeof(LibK_SetCleanupCallbackDelegate));
            LibK_LoadDriverAPI = (LibK_LoadDriverAPIDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_LoadDriverAPI"), typeof(LibK_LoadDriverAPIDelegate));
            LibK_IsFunctionSupported = (LibK_IsFunctionSupportedDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_IsFunctionSupported"), typeof(LibK_IsFunctionSupportedDelegate));
            LibK_CopyDriverAPI = (LibK_CopyDriverAPIDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_CopyDriverAPI"), typeof(LibK_CopyDriverAPIDelegate));
            LibK_GetProcAddress = (LibK_GetProcAddressDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_GetProcAddress"), typeof(LibK_GetProcAddressDelegate));
            LibK_SetDefaultContext = (LibK_SetDefaultContextDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_SetDefaultContext"), typeof(LibK_SetDefaultContextDelegate));
            LibK_GetDefaultContext = (LibK_GetDefaultContextDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_GetDefaultContext"), typeof(LibK_GetDefaultContextDelegate));
            LibK_Context_Init = (LibK_Context_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_Context_Init"), typeof(LibK_Context_InitDelegate));
            LibK_Context_Free = (LibK_Context_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LibK_Context_Free"), typeof(LibK_Context_FreeDelegate));
            UsbK_Free = (UsbK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "UsbK_Free"), typeof(UsbK_FreeDelegate));
            LstK_Init = (LstK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_Init"), typeof(LstK_InitDelegate));
            LstK_InitEx = (LstK_InitExDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_InitEx"), typeof(LstK_InitExDelegate));
            LstK_Free = (LstK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_Free"), typeof(LstK_FreeDelegate));
            LstK_Enumerate = (LstK_EnumerateDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_Enumerate"), typeof(LstK_EnumerateDelegate));
            LstK_Current = (LstK_CurrentDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_Current"), typeof(LstK_CurrentDelegate));
            LstK_MoveNext = (LstK_MoveNextDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_MoveNext"), typeof(LstK_MoveNextDelegate));
            LstK_MoveReset = (LstK_MoveResetDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_MoveReset"), typeof(LstK_MoveResetDelegate));
            LstK_FindByVidPid = (LstK_FindByVidPidDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_FindByVidPid"), typeof(LstK_FindByVidPidDelegate));
            LstK_Count = (LstK_CountDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LstK_Count"), typeof(LstK_CountDelegate));
            HotK_Init = (HotK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "HotK_Init"), typeof(HotK_InitDelegate));
            HotK_Free = (HotK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "HotK_Free"), typeof(HotK_FreeDelegate));
            HotK_FreeAll = (HotK_FreeAllDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "HotK_FreeAll"), typeof(HotK_FreeAllDelegate));
            OvlK_Acquire = (OvlK_AcquireDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_Acquire"), typeof(OvlK_AcquireDelegate));
            OvlK_Release = (OvlK_ReleaseDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_Release"), typeof(OvlK_ReleaseDelegate));
            OvlK_Init = (OvlK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_Init"), typeof(OvlK_InitDelegate));
            OvlK_Free = (OvlK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_Free"), typeof(OvlK_FreeDelegate));
            OvlK_GetEventHandle = (OvlK_GetEventHandleDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_GetEventHandle"), typeof(OvlK_GetEventHandleDelegate));
            OvlK_Wait = (OvlK_WaitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_Wait"), typeof(OvlK_WaitDelegate));
            OvlK_WaitOldest = (OvlK_WaitOldestDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_WaitOldest"), typeof(OvlK_WaitOldestDelegate));
            OvlK_WaitOrCancel = (OvlK_WaitOrCancelDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_WaitOrCancel"), typeof(OvlK_WaitOrCancelDelegate));
            OvlK_WaitAndRelease = (OvlK_WaitAndReleaseDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_WaitAndRelease"), typeof(OvlK_WaitAndReleaseDelegate));
            OvlK_IsComplete = (OvlK_IsCompleteDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_IsComplete"), typeof(OvlK_IsCompleteDelegate));
            OvlK_ReUse = (OvlK_ReUseDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "OvlK_ReUse"), typeof(OvlK_ReUseDelegate));
            StmK_Init = (StmK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Init"), typeof(StmK_InitDelegate));
            StmK_Free = (StmK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Free"), typeof(StmK_FreeDelegate));
            StmK_Start = (StmK_StartDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Start"), typeof(StmK_StartDelegate));
            StmK_Stop = (StmK_StopDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Stop"), typeof(StmK_StopDelegate));
            StmK_Read = (StmK_ReadDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Read"), typeof(StmK_ReadDelegate));
            StmK_Write = (StmK_WriteDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "StmK_Write"), typeof(StmK_WriteDelegate));
            IsoK_Init = (IsoK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_Init"), typeof(IsoK_InitDelegate));
            IsoK_Free = (IsoK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_Free"), typeof(IsoK_FreeDelegate));
            IsoK_SetPackets = (IsoK_SetPacketsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_SetPackets"), typeof(IsoK_SetPacketsDelegate));
            IsoK_SetPacket = (IsoK_SetPacketDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_SetPacket"), typeof(IsoK_SetPacketDelegate));
            IsoK_GetPacket = (IsoK_GetPacketDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_GetPacket"), typeof(IsoK_GetPacketDelegate));
            IsoK_EnumPackets = (IsoK_EnumPacketsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_EnumPackets"), typeof(IsoK_EnumPacketsDelegate));
            IsoK_ReUse = (IsoK_ReUseDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsoK_ReUse"), typeof(IsoK_ReUseDelegate));
            IsochK_Init = (IsochK_InitDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_Init"), typeof(IsochK_InitDelegate));
            IsochK_Free = (IsochK_FreeDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_Free"), typeof(IsochK_FreeDelegate));
            IsochK_SetPacketOffsets = (IsochK_SetPacketOffsetsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_SetPacketOffsets"), typeof(IsochK_SetPacketOffsetsDelegate));
            IsochK_SetPacket = (IsochK_SetPacketDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_SetPacket"), typeof(IsochK_SetPacketDelegate));
            IsochK_GetPacket = (IsochK_GetPacketDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_GetPacket"), typeof(IsochK_GetPacketDelegate));
            IsochK_EnumPackets = (IsochK_EnumPacketsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_EnumPackets"), typeof(IsochK_EnumPacketsDelegate));
            IsochK_CalcPacketInformation = (IsochK_CalcPacketInformationDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_CalcPacketInformation"), typeof(IsochK_CalcPacketInformationDelegate));
            IsochK_GetNumberOfPackets = (IsochK_GetNumberOfPacketsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_GetNumberOfPackets"), typeof(IsochK_GetNumberOfPacketsDelegate));
            IsochK_SetNumberOfPackets = (IsochK_SetNumberOfPacketsDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "IsochK_SetNumberOfPackets"), typeof(IsochK_SetNumberOfPacketsDelegate));
            LUsb0_ControlTransfer = (LUsb0_ControlTransferDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LUsb0_ControlTransfer"), typeof(LUsb0_ControlTransferDelegate));
            LUsb0_SetConfiguration = (LUsb0_SetConfigurationDelegate) Marshal.GetDelegateForFunctionPointer(GetProcAddress(mModuleLibusbK, "LUsb0_SetConfiguration"), typeof(LUsb0_SetConfigurationDelegate));
        }

        [Flags]
        enum LoadLibraryFlags
        {
            NONE = 0,
            DONT_RESOLVE_DLL_REFERENCES = 0x00000001,
            LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x00000010,
            LOAD_LIBRARY_AS_DATAFILE = 0x00000002,
            LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 0x00000040,
            LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020,
            LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008
        }
    }

    #endregion

    #region Enumerations

    /// <Summary>Values used in the \c bmAttributes field of a \ref USB_ENDPOINT_DESCRIPTOR</Summary>
    public enum USBD_PIPE_TYPE
    {
        /// <Summary>Indicates a control endpoint</Summary>
        UsbdPipeTypeControl,

        /// <Summary>Indicates an isochronous endpoint</Summary>
        UsbdPipeTypeIsochronous,

        /// <Summary>Indicates a bulk endpoint</Summary>
        UsbdPipeTypeBulk,

        /// <Summary>Indicates an interrupt endpoint</Summary>
        UsbdPipeTypeInterrupt,
    }

    /// <Summary>Additional ISO transfer flags.</Summary>
    [Flags]
    public enum KISO_FLAG
    {
        NONE = 0,

        /// <Summary>Do not start the transfer immediately, instead use \ref KISO_CONTEXT::StartFrame.</Summary>
        SET_START_FRAME = 0x00000001,
    }

    /// <Summary>Handle type enumeration.</Summary>
    public enum KLIB_HANDLE_TYPE
    {
        /// <Summary>Hot plug handle. \ref KHOT_HANDLE</Summary>
        HOTK,

        /// <Summary>USB handle. \ref KUSB_HANDLE</Summary>
        USBK,

        /// <Summary>Shared USB handle. \ref KUSB_HANDLE</Summary>
        USBSHAREDK,

        /// <Summary>Device list handle. \ref KLST_HANDLE</Summary>
        LSTK,

        /// <Summary>Device info handle. \ref KLST_DEVINFO_HANDLE</Summary>
        LSTINFOK,

        /// <Summary>Overlapped handle. \ref KOVL_HANDLE</Summary>
        OVLK,

        /// <Summary>Overlapped pool handle. \ref KOVL_POOL_HANDLE</Summary>
        OVLPOOLK,

        /// <Summary>Pipe stream handle. \ref KSTM_HANDLE</Summary>
        STMK,

        /// <Summary>Pipe stream handle. \ref KSTM_HANDLE</Summary>
        ISOCHK,

        /// <Summary>Max handle type count.</Summary>
        COUNT
    }

    /// <Summary>Device list sync flags.</Summary>
    [Flags]
    public enum KLST_SYNC_FLAG
    {
        /// <Summary>Cleared/invalid state.</Summary>
        NONE = 0,

        /// <Summary>Unchanged state,</Summary>
        UNCHANGED = 0x0001,

        /// <Summary>Added (Arrival) state,</Summary>
        ADDED = 0x0002,

        /// <Summary>Removed (Unplugged) state,</Summary>
        REMOVED = 0x0004,

        /// <Summary>Connect changed state.</Summary>
        CONNECT_CHANGE = 0x0008,

        /// <Summary>All states.</Summary>
        MASK = 0x000F,
    }

    /// <Summary>Device list initialization flags.</Summary>
    [Flags]
    public enum KLST_FLAG
    {
        /// <Summary>No flags (or 0)</Summary>
        NONE = 0,

        /// <Summary>Enable listings for the raw device interface GUID \b only. {A5DCBF10-6530-11D2-901F-00C04FB951ED}</Summary>
        INCLUDE_RAWGUID = 0x0001,

        /// <Summary>List all libusbK devices including those not currently connected.</Summary>
        INCLUDE_DISCONNECT = 0x0002,
    }

    /// <Summary>bmRequest.Dir</Summary>
    public enum BMREQUEST_DIR
    {
        HOST_TO_DEVICE = 0,
        DEVICE_TO_HOST = 1,
    }

    /// <Summary>bmRequest.Type</Summary>
    public enum BMREQUEST_TYPE
    {
        /// <Summary>Standard request. See \ref USB_REQUEST_ENUM</Summary>
        STANDARD = 0,

        /// <Summary>Class-specific request.</Summary>
        CLASS = 1,

        /// <Summary>Vendor-specific request</Summary>
        VENDOR = 2,
    }

    /// <Summary>bmRequest.Recipient</Summary>
    public enum BMREQUEST_RECIPIENT
    {
        /// <Summary>Request is for a device.</Summary>
        DEVICE = 0,

        /// <Summary>Request is for an interface of a device.</Summary>
        INTERFACE = 1,

        /// <Summary>Request is for an endpoint of a device.</Summary>
        ENDPOINT = 2,

        /// <Summary>Request is for a vendor-specific purpose.</Summary>
        OTHER = 3,
    }

    /// <Summary>Values for the bits returned by the \ref USB_REQUEST_GET_STATUS request.</Summary>
    public enum USB_GETSTATUS
    {
        /// <Summary>Device is self powered</Summary>
        SELF_POWERED = 0x01,

        /// <Summary>Device can wake the system from a low power/sleeping state.</Summary>
        REMOTE_WAKEUP_ENABLED = 0x02
    }

    /// <Summary>Standard USB descriptor types. For more information, see section 9-5 of the USB 3.0 specifications.</Summary>
    public enum USB_DESCRIPTOR_TYPE
    {
        /// <Summary>Device descriptor type.</Summary>
        DEVICE = 0x01,

        /// <Summary>Configuration descriptor type.</Summary>
        CONFIGURATION = 0x02,

        /// <Summary>String descriptor type.</Summary>
        STRING = 0x03,

        /// <Summary>Interface descriptor type.</Summary>
        INTERFACE = 0x04,

        /// <Summary>Endpoint descriptor type.</Summary>
        ENDPOINT = 0x05,

        /// <Summary>Device qualifier descriptor type.</Summary>
        DEVICE_QUALIFIER = 0x06,

        /// <Summary>Config power descriptor type.</Summary>
        CONFIG_POWER = 0x07,

        /// <Summary>Interface power descriptor type.</Summary>
        INTERFACE_POWER = 0x08,

        /// <Summary>Interface association descriptor type.</Summary>
        INTERFACE_ASSOCIATION = 0x0B,

        /// <Summary>BOS descriptor type</Summary>
        BOS = 0x0F,

        /// <Summary>Device capabilities descriptor type</Summary>
        DEVICE_CAPS = 0x10,

        /// <Summary>Superspeed endpoint companion descriptor type</Summary>
        USB_SUPERSPEED_ENDPOINT_COMPANION = 0x30,
    }

    /// <Summary>Values used in the \c bmAttributes field of a \ref USB_CONFIGURATION_DESCRIPTOR</Summary>
    public enum USB_CONFIG_BM_ATTRIBUTE_ENUM
    {
        /// <Summary>The device is powered by it's host.</Summary>
        USB_CONFIG_BUS_POWERED = 0x80,

        /// <Summary>The device has an external power source.</Summary>
        USB_CONFIG_SELF_POWERED = 0x40,

        /// <Summary>The device is capable of waking the the host from a low power/sleeping state.</Summary>
        USB_CONFIG_REMOTE_WAKEUP = 0x20,
    }

    /// <Summary>USB defined request codes</Summary>
    public enum USB_REQUEST_ENUM
    {
        /// <Summary>Request status of the specific recipient</Summary>
        USB_REQUEST_GET_STATUS = 0x00,

        /// <Summary>Clear or disable a specific feature</Summary>
        USB_REQUEST_CLEAR_FEATURE = 0x01,

        /// <Summary>Set or enable a specific feature</Summary>
        USB_REQUEST_SET_FEATURE = 0x03,

        /// <Summary>Set device address for all future accesses</Summary>
        USB_REQUEST_SET_ADDRESS = 0x05,

        /// <Summary>Get the specified descriptor</Summary>
        USB_REQUEST_GET_DESCRIPTOR = 0x06,

        /// <Summary>Update existing descriptors or add new descriptors</Summary>
        USB_REQUEST_SET_DESCRIPTOR = 0x07,

        /// <Summary>Get the current device configuration value</Summary>
        USB_REQUEST_GET_CONFIGURATION = 0x08,

        /// <Summary>Set device configuration</Summary>
        USB_REQUEST_SET_CONFIGURATION = 0x09,

        /// <Summary>Return the selected alternate setting for the specified interface</Summary>
        USB_REQUEST_GET_INTERFACE = 0x0A,

        /// <Summary>Select an alternate interface for the specified interface</Summary>
        USB_REQUEST_SET_INTERFACE = 0x0B,

        /// <Summary>Set then report an endpoint's synchronization frame</Summary>
        USB_REQUEST_SYNC_FRAME = 0x0C,
    }

    /// <Summary>USB defined class codes</Summary>
    public enum USB_DEVICE_CLASS_ENUM
    {
        /// <Summary>Reserved class</Summary>
        USB_DEVICE_CLASS_RESERVED = 0x00,

        /// <Summary>Audio class</Summary>
        USB_DEVICE_CLASS_AUDIO = 0x01,

        /// <Summary>Communications class</Summary>
        USB_DEVICE_CLASS_COMMUNICATIONS = 0x02,

        /// <Summary>Human Interface Device class</Summary>
        USB_DEVICE_CLASS_HUMAN_INTERFACE = 0x03,

        /// <Summary>Imaging class</Summary>
        USB_DEVICE_CLASS_IMAGING = 0x06,

        /// <Summary>Printer class</Summary>
        USB_DEVICE_CLASS_PRINTER = 0x07,

        /// <Summary>Mass storage class</Summary>
        USB_DEVICE_CLASS_STORAGE = 0x08,

        /// <Summary>Hub class</Summary>
        USB_DEVICE_CLASS_HUB = 0x09,

        /// <Summary>vendor-specific class</Summary>
        USB_DEVICE_CLASS_VENDOR_SPECIFIC = 0xFF,
    }

    /// <Summary>USB BOS capability types</Summary>
    public enum BOS_CAPABILITY_TYPE
    {
        /// <Summary>Wireless USB device capability.</Summary>
        WIRELESS_USB_DEVICE_CAPABILITY = 0x01,

        /// <Summary>USB 2.0 extensions.</Summary>
        USB_2_0_EXTENSION = 0x02,

        /// <Summary>SuperSpeed USB device capability.</Summary>
        SS_USB_DEVICE_CAPABILITY = 0x03,

        /// <Summary>Container ID type.</Summary>
        CONTAINER_ID = 0x04,

        /// <Summary>Platform specific capability.</Summary>
        PLATFORM = 0x05,

        /// <Summary>Defines the various PD Capabilities of this device.</Summary>
        BOS_POWER_DELIVERY_CAPABILITY = 0x06,

        /// <Summary>Provides information on each battery supported by the device.</Summary>
        BOS_BATTERY_INFO_CAPABILITY = 0x07,

        /// <Summary>The consumer characteristics of a port on the device.</Summary>
        BOS_PD_CONSUMER_PORT_CAPABILITY = 0x08,

        /// <Summary>The provider characteristics of a port on the device.</Summary>
        BOS_PD_PROVIDER_PORT_CAPABILITY = 0x09,

        /// <Summary>Defines the set of SuperSpeed Plus USB specific device level capabilities.</Summary>
        BOS_SUPERSPEED_PLUS = 0x0A,

        /// <Summary>Precision Time Measurement (PTM) Capability Descriptor.</Summary>
        BOS_PRECISION_TIME_MEASUREMENT = 0x0B,

        /// <Summary>Defines the set of Wireless USB 1.1-specific device level capabilities.</Summary>
        BOS_WIRELESS_USB_EXT = 0x0C,

        /// <Summary>Billboard capability.</Summary>
        BOS_BILLBOARD = 0x0D,

        /// <Summary>Authentication Capability Descriptor.</Summary>
        BOS_AUTHENTICATION = 0x0E,

        /// <Summary>Billboard Ex capability.</Summary>
        BOS_BILLBOARD_EX = 0x0F,

        /// <Summary>Summarizes configuration information for a function implemented by the device.</Summary>
        BOS_CONFIGURATION_SUMMARY = 0x10,
    }

    /// <Summary>Microsoft feature descriptor types.</Summary>
    public enum MSOS_FEATURE_TYPE
    {
        /// <Summary>Microsoft OS V1.0 compatible IDs descriptor</Summary>
        V1_EXTENDED_COMPAT_ID = 0x0004,

        /// <Summary>Microsoft OS V1.0 extended properties descriptor</Summary>
        V1_EXTENDED_PROPS = 0x0005,

        /// <Summary>Microsoft OS V2.0 descriptor set</Summary>
        V2_DESCRIPTOR_SET = 0x0007,
    }

    /// <Summary>Microsoft OS 2.0 descriptor wDescriptorType values</Summary>
    public enum MSOSV2_DESCRIPTOR_TYPE
    {
        /// <Summary>The MS OS 2.0 descriptor set header.</Summary>
        SET_HEADER_DESCRIPTOR = 0x00,

        /// <Summary>Microsoft OS 2.0 configuration subset header.</Summary>
        SUBSET_HEADER_CONFIGURATION = 0x01,

        /// <Summary>Microsoft OS 2.0 function subset header.</Summary>
        SUBSET_HEADER_FUNCTION = 0x02,

        /// <Summary>Microsoft OS 2.0 compatible ID descriptor.</Summary>
        FEATURE_COMPATIBLE_ID = 0x03,

        /// <Summary>Microsoft OS 2.0 registry property descriptor.</Summary>
        FEATURE_REG_PROPERTY = 0x04,

        /// <Summary>Microsoft OS 2.0 minimum USB resume time descriptor.</Summary>
        FEATURE_MIN_RESUME_TIME = 0x05,

        /// <Summary>Microsoft OS 2.0 model ID descriptor.</Summary>
        FEATURE_MODEL_ID = 0x06,

        /// <Summary>Microsoft OS 2.0 CCGP device descriptor.</Summary>
        FEATURE_CCGP_DEVICE = 0x07,

        /// <Summary>Microsoft OS 2.0 vendor revision descriptor.</Summary>
        FEATURE_VENDOR_REVISION = 0x08,
    }

    /// <Summary>Usb handle specific properties that can be retrieved with \ref UsbK_GetProperty.</Summary>
    public enum KUSB_PROPERTY
    {
        /// <Summary>Get the internal device file handle used for operations such as GetOverlappedResult or DeviceIoControl.</Summary>
        DEVICE_FILE_HANDLE,

        COUNT
    }

    /// <Summary>Supported driver id enumeration.</Summary>
    public enum KUSB_DRVID
    {
        /// <Summary>libusbK.sys driver ID</Summary>
        LIBUSBK,

        /// <Summary>libusb0.sys driver ID</Summary>
        LIBUSB0,

        /// <Summary>WinUSB.sys driver ID</Summary>
        WINUSB,

        /// <Summary>libusb0.sys filter driver ID</Summary>
        LIBUSB0_FILTER,

        /// <Summary>Supported driver count</Summary>
        COUNT
    }

    /// <Summary>Supported function id enumeration.</Summary>
    public enum KUSB_FNID
    {
        /// <Summary>\ref UsbK_Init dynamic driver function id.</Summary>
        Init,

        /// <Summary>\ref UsbK_Free dynamic driver function id.</Summary>
        Free,

        /// <Summary>\ref UsbK_ClaimInterface dynamic driver function id.</Summary>
        ClaimInterface,

        /// <Summary>\ref UsbK_ReleaseInterface dynamic driver function id.</Summary>
        ReleaseInterface,

        /// <Summary>\ref UsbK_SetAltInterface dynamic driver function id.</Summary>
        SetAltInterface,

        /// <Summary>\ref UsbK_GetAltInterface dynamic driver function id.</Summary>
        GetAltInterface,

        /// <Summary>\ref UsbK_GetDescriptor dynamic driver function id.</Summary>
        GetDescriptor,

        /// <Summary>\ref UsbK_ControlTransfer dynamic driver function id.</Summary>
        ControlTransfer,

        /// <Summary>\ref UsbK_SetPowerPolicy dynamic driver function id.</Summary>
        SetPowerPolicy,

        /// <Summary>\ref UsbK_GetPowerPolicy dynamic driver function id.</Summary>
        GetPowerPolicy,

        /// <Summary>\ref UsbK_SetConfiguration dynamic driver function id.</Summary>
        SetConfiguration,

        /// <Summary>\ref UsbK_GetConfiguration dynamic driver function id.</Summary>
        GetConfiguration,

        /// <Summary>\ref UsbK_ResetDevice dynamic driver function id.</Summary>
        ResetDevice,

        /// <Summary>\ref UsbK_Initialize dynamic driver function id.</Summary>
        Initialize,

        /// <Summary>\ref UsbK_SelectInterface dynamic driver function id.</Summary>
        SelectInterface,

        /// <Summary>\ref UsbK_GetAssociatedInterface dynamic driver function id.</Summary>
        GetAssociatedInterface,

        /// <Summary>\ref UsbK_Clone dynamic driver function id.</Summary>
        Clone,

        /// <Summary>\ref UsbK_QueryInterfaceSettings dynamic driver function id.</Summary>
        QueryInterfaceSettings,

        /// <Summary>\ref UsbK_QueryDeviceInformation dynamic driver function id.</Summary>
        QueryDeviceInformation,

        /// <Summary>\ref UsbK_SetCurrentAlternateSetting dynamic driver function id.</Summary>
        SetCurrentAlternateSetting,

        /// <Summary>\ref UsbK_GetCurrentAlternateSetting dynamic driver function id.</Summary>
        GetCurrentAlternateSetting,

        /// <Summary>\ref UsbK_QueryPipe dynamic driver function id.</Summary>
        QueryPipe,

        /// <Summary>\ref UsbK_SetPipePolicy dynamic driver function id.</Summary>
        SetPipePolicy,

        /// <Summary>\ref UsbK_GetPipePolicy dynamic driver function id.</Summary>
        GetPipePolicy,

        /// <Summary>\ref UsbK_ReadPipe dynamic driver function id.</Summary>
        ReadPipe,

        /// <Summary>\ref UsbK_WritePipe dynamic driver function id.</Summary>
        WritePipe,

        /// <Summary>\ref UsbK_ResetPipe dynamic driver function id.</Summary>
        ResetPipe,

        /// <Summary>\ref UsbK_AbortPipe dynamic driver function id.</Summary>
        AbortPipe,

        /// <Summary>\ref UsbK_FlushPipe dynamic driver function id.</Summary>
        FlushPipe,

        /// <Summary>\ref UsbK_IsoReadPipe dynamic driver function id.</Summary>
        IsoReadPipe,

        /// <Summary>\ref UsbK_IsoWritePipe dynamic driver function id.</Summary>
        IsoWritePipe,

        /// <Summary>\ref UsbK_GetCurrentFrameNumber dynamic driver function id.</Summary>
        GetCurrentFrameNumber,

        /// <Summary>\ref UsbK_GetOverlappedResult dynamic driver function id.</Summary>
        GetOverlappedResult,

        /// <Summary>\ref UsbK_GetProperty dynamic driver function id.</Summary>
        GetProperty,

        /// <Summary>\ref UsbK_IsochReadPipe dynamic driver function id.</Summary>
        IsochReadPipe,

        /// <Summary>\ref UsbK_IsochWritePipe dynamic driver function id.</Summary>
        IsochWritePipe,

        /// <Summary>\ref UsbK_QueryPipeEx dynamic driver function id.</Summary>
        QueryPipeEx,

        /// <Summary>\ref UsbK_GetSuperSpeedPipeCompanionDescriptor dynamic driver function id.</Summary>
        GetSuperSpeedPipeCompanionDescriptor,

        /// <Summary>Supported function count</Summary>
        COUNT,
    }

    /// <Summary>Hot plug config flags.</Summary>
    [Flags]
    public enum KHOT_FLAG
    {
        /// <Summary>No flags (or 0)</Summary>
        NONE,

        /// <Summary>Notify all devices which match upon a succuessful call to \ref HotK_Init.</Summary>
        PLUG_ALL_ON_INIT = 0x0001,

        /// <Summary>Allow other \ref KHOT_HANDLE instances to consume this match.</Summary>
        PASS_DUPE_INSTANCE = 0x0002,

        /// <Summary>If a \c UserHwnd is specified, use \c PostMessage instead of \c SendMessage.</Summary>
        POST_USER_MESSAGE = 0x0004,
    }

    /// <Summary>\c WaitFlags used by \ref OvlK_Wait.</Summary>
    [Flags]
    public enum KOVL_WAIT_FLAG
    {
        /// <Summary>Do not perform any additional actions upon exiting \ref OvlK_Wait.</Summary>
        NONE = 0,

        /// <Summary>If the i/o operation completes successfully, release the OverlappedK back to it's pool.</Summary>
        RELEASE_ON_SUCCESS = 0x0001,

        /// <Summary>If the i/o operation fails, release the OverlappedK back to it's pool.</Summary>
        RELEASE_ON_FAIL = 0x0002,

        /// <Summary>
        ///     If the i/o operation fails or completes successfully, release the OverlappedK back to its pool. Perform no
        ///     actions if it times-out.
        /// </Summary>
        RELEASE_ON_SUCCESS_FAIL = 0x0003,

        /// <Summary>If the i/o operation times-out cancel it, but do not release the OverlappedK back to its pool.</Summary>
        CANCEL_ON_TIMEOUT = 0x0004,

        /// <Summary>If the i/o operation times-out, cancel it and release the OverlappedK back to its pool.</Summary>
        RELEASE_ON_TIMEOUT = 0x000C,

        /// <Summary>
        ///     Always release the OverlappedK back to its pool.  If the operation timed-out, cancel it before releasing back
        ///     to its pool.
        /// </Summary>
        RELEASE_ALWAYS = 0x000F,

        /// <Summary>
        ///     Uses alterable wait functions.  See
        ///     http://msdn.microsoft.com/en-us/library/windows/desktop/ms687036%28v=vs.85%29.aspx
        /// </Summary>
        ALERTABLE = 0x0010,
    }

    /// <Summary>\c Overlapped pool config flags.</Summary>
    [Flags]
    public enum KOVL_POOL_FLAG
    {
        NONE = 0,
    }

    /// <Summary>Stream config flags.</Summary>
    [Flags]
    public enum KSTM_FLAG : uint
    {
        /// <Summary>None</Summary>
        NONE = 0,
        NO_PARTIAL_XFERS = 0x00100000,
        USE_TIMEOUT = 0x80000000,
        TIMEOUT_MASK = 0x0001FFFF
    }

    /// <Summary>Stream config flags.</Summary>
    public enum KSTM_COMPLETE_RESULT
    {
        /// <Summary>Valid</Summary>
        VALID = 0,

        /// <Summary>Invalid</Summary>
        INVALID,
    }

    #endregion

    #region Structs

    /// <Summary>
    ///     The \c WINUSB_PIPE_INFORMATION structure contains pipe information that the \ref UsbK_QueryPipe routine
    ///     retrieves.
    /// </Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct WINUSB_PIPE_INFORMATION
    {
        /// <Summary>A \c USBD_PIPE_TYPE enumeration value that specifies the pipe type</Summary>
        public USBD_PIPE_TYPE PipeType;

        /// <Summary>The pipe identifier (ID)</Summary>
        public byte PipeId;

        /// <Summary>The maximum size, in bytes, of the packets that are transmitted on the pipe</Summary>
        public ushort MaximumPacketSize;

        /// <Summary>The pipe interval</Summary>
        public byte Interval;


        public override string ToString()
        {
            return string.Format("PipeType: {0}\nPipeId: {1}\nMaximumPacketSize: {2}\nInterval: {3}\n", PipeType, PipeId.ToString("X2") + "h", MaximumPacketSize, Interval.ToString("X2") + "h");
        }
    }

    /// <Summary>
    ///     The \c WINUSB_PIPE_INFORMATION_EX structure contains pipe information that the \ref UsbK_QueryPipeEx routine
    ///     retrieves.
    /// </Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct WINUSB_PIPE_INFORMATION_EX
    {
        /// <Summary>A \c USBD_PIPE_TYPE enumeration value that specifies the pipe type</Summary>
        public USBD_PIPE_TYPE PipeType;

        /// <Summary>The pipe identifier (ID)</Summary>
        public byte PipeId;

        /// <Summary>The maximum size, in bytes, of the packets that are transmitted on the pipe</Summary>
        public ushort MaximumPacketSize;

        /// <Summary>The pipe interval</Summary>
        public byte Interval;

        /// <Summary>The maximum number of bytes that can be transmitted in single interval.</Summary>
        public uint MaximumBytesPerInterval;


        public override string ToString()
        {
            return string.Format("PipeType: {0}\nPipeId: {1}\nMaximumPacketSize: {2}\nInterval: {3}\nMaximumBytesPerInterval: {4}\n", PipeType, PipeId.ToString("X2") + "h", MaximumPacketSize, Interval.ToString("X2") + "h", MaximumBytesPerInterval);
        }
    }

    /// <Summary>The \c WINUSB_SETUP_PACKET structure describes a USB setup packet.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct WINUSB_SETUP_PACKET
    {
        /// <Summary>
        ///     The request type. The values that are assigned to this member are defined in Table 9.2 of section 9.3 of the
        ///     Universal Serial Bus (USB) specification (www.usb.org).
        /// </Summary>
        public byte RequestType;

        /// <Summary>
        ///     The device request. The values that are assigned to this member are defined in Table 9.3 of section 9.4 of the
        ///     Universal Serial Bus (USB) specification.
        /// </Summary>
        public byte Request;

        /// <Summary>
        ///     The meaning of this member varies according to the request. For an explanation of this member, see the
        ///     Universal Serial Bus (USB) specification.
        /// </Summary>
        public ushort Value;

        /// <Summary>
        ///     The meaning of this member varies according to the request. For an explanation of this member, see the
        ///     Universal Serial Bus (USB) specification.
        /// </Summary>
        public ushort Index;

        /// <Summary>The number of bytes to transfer. (not including the \c WINUSB_SETUP_PACKET itself)</Summary>
        public ushort Length;


        public override string ToString()
        {
            return string.Format("RequestType: {0}\nRequest: {1}\nValue: {2}\nIndex: {3}\nLength: {4}\n", RequestType.ToString("X2") + "h", Request.ToString("X2") + "h", Value.ToString("X4") + "h", Index.ToString("X4") + "h", Length);
        }
    }

    /// <Summary>Structure describing an isochronous transfer packet for libusbK.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct KISO_PACKET
    {
        /// <Summary>
        ///     Specifies the offset, in bytes, of the buffer for this packet from the beginning of the entire isochronous
        ///     transfer data buffer.
        /// </Summary>
        public uint Offset;

        /// <Summary>
        ///     Set by the host controller to indicate the actual number of bytes received by the device for isochronous IN
        ///     transfers. Length not used for isochronous OUT transfers.
        /// </Summary>
        public ushort Length;

        /// <Summary>
        ///     Contains the 16 least significant USBD status bits, on return from the host controller driver, of this
        ///     transfer packet.
        /// </Summary>
        public ushort Status;


        public override string ToString()
        {
            return string.Format("Offset: {0}\nLength: {1}\nStatus: {2}\n", Offset, Length, Status.ToString("X4") + "h");
        }
    }

    /// <Summary>Structure describing an isochronous transfer packet for winusb.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct KISO_WUSB_PACKET
    {
        /// <Summary>
        ///     Specifies the offset, in bytes, of the buffer for this packet from the beginning of the entire isochronous
        ///     transfer data buffer.
        /// </Summary>
        public uint Offset;

        /// <Summary>
        ///     Set by the host controller to indicate the actual number of bytes received by the device for isochronous IN
        ///     transfers. Length not used for isochronous OUT transfers.
        /// </Summary>
        public uint Length;

        /// <Summary>
        ///     Contains the 16 least significant USBD status bits, on return from the host controller driver, of this
        ///     transfer packet.
        /// </Summary>
        public uint Status;


        public override string ToString()
        {
            return string.Format("Offset: {0}\nLength: {1}\nStatus: {2}\n", Offset, Length, Status);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct KISO_CONTEXT
    {
        private readonly IntPtr mHandlePtr;

        public KISO_CONTEXT(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        /// <summary>KISO_CONTEXT_MAP is used for calculating field offsets only</summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
        private struct KISO_CONTEXT_MAP
        {
            /// <Summary>Additional ISO transfer flags. See \ref KISO_FLAG.</Summary>
            private readonly KISO_FLAG Flags;

            /// <Summary>Specifies the frame number that the transfer should begin on (0 for ASAP).</Summary>
            private readonly uint StartFrame;

            /// <Summary>
            ///     Contains the number of packets that completed with an error condition on return from the host controller
            ///     driver.
            /// </Summary>
            private readonly short ErrorCount;

            /// <Summary>Specifies the number of packets that are described by the variable-length array member \c IsoPacket.</Summary>
            private readonly short NumberOfPackets;

            /// <Summary>Contains the URB Hdr.Status value on return from the host controller driver.</Summary>
            private readonly uint UrbHdrStatus;
        }

        private static readonly int ofsFlags = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "Flags").ToInt32();
        private static readonly int ofsStartFrame = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "StartFrame").ToInt32();
        private static readonly int ofsErrorCount = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "ErrorCount").ToInt32();
        private static readonly int ofsNumberOfPackets = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "NumberOfPackets").ToInt32();
        private static readonly int ofsUrbHdrStatus = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "UrbHdrStatus").ToInt32();


        /// <Summary>Additional ISO transfer flags. See \ref KISO_FLAG.</Summary>
        public KISO_FLAG Flags
        {
            get { return (KISO_FLAG) Marshal.ReadInt32(mHandlePtr, ofsFlags); }
        }


        /// <Summary>Specifies the frame number that the transfer should begin on (0 for ASAP).</Summary>

        public uint StartFrame
        {
            get { return (uint) Marshal.ReadInt32(mHandlePtr, ofsStartFrame); }
        }


        /// <Summary>
        ///     Contains the number of packets that completed with an error condition on return from the host controller
        ///     driver.
        /// </Summary>

        public short ErrorCount
        {
            get { return Marshal.ReadInt16(mHandlePtr, ofsErrorCount); }
        }


        /// <Summary>Specifies the number of packets that are described by the variable-length array member \c IsoPacket.</Summary>

        public short NumberOfPackets
        {
            get { return Marshal.ReadInt16(mHandlePtr, ofsNumberOfPackets); }
        }


        /// <Summary>Contains the URB Hdr.Status value on return from the host controller driver.</Summary>

        public uint UrbHdrStatus
        {
            get { return (uint) Marshal.ReadInt32(mHandlePtr, ofsUrbHdrStatus); }
        }


        public override string ToString()
        {
            return string.Format("Flags: {0}\nStartFrame: {1}\nErrorCount: {2}\nNumberOfPackets: {3}\nUrbHdrStatus: {4}\n", Flags.ToString(), StartFrame, ErrorCount, NumberOfPackets, UrbHdrStatus.ToString("X8") + "h");
        }
    }

    /// <Summary>Structure describing additional information about how an isochronous pipe transfers data.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct KISOCH_PACKET_INFORMATION
    {
        /// <Summary>Number of ISO packets transferred per whole USB frame (1 millisecond).</Summary>
        public uint PacketsPerFrame;

        /// <Summary>How often a pipe transfers data.</Summary>
        public uint PollingPeriodMicroseconds;


        /// <Summary>Number of bytes transferred per millisecond (or whole frame).</Summary>
        public uint BytesPerMillisecond;


        public override string ToString()
        {
            return string.Format("PacketsPerFrame: {0}\nPollingPeriodMicroseconds: {1}\nBytesPerMillisecond: {2}\n", PacketsPerFrame, PollingPeriodMicroseconds, BytesPerMillisecond);
        }
    }

    /// <Summary>libusbK verson information structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct KLIB_VERSION
    {
        /// <Summary>Major version number.</Summary>
        public int Major;

        /// <Summary>Minor version number.</Summary>
        public int Minor;

        /// <Summary>Micro version number.</Summary>
        public int Micro;

        /// <Summary>Nano version number.</Summary>
        public int Nano;

        public override string ToString()
        {
            return string.Format("Major: {0}\nMinor: {1}\nMicro: {2}\nNano: {3}\n", Major, Minor, Micro, Nano);
        }
    }

    /// <Summary>Common usb device information structure</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct KLST_DEV_COMMON_INFO
    {
        /// <Summary>VendorID parsed from \ref KLST_DEVINFO::DeviceID</Summary>
        public int Vid;

        /// <Summary>ProductID parsed from \ref KLST_DEVINFO::DeviceID</Summary>
        public int Pid;

        /// <Summary>
        ///     Composite interface number parsed from \ref KLST_DEVINFO::DeviceID.  Set to \b -1 for devices that do not have
        ///     the composite parent driver.
        /// </Summary>
        public int MI;

        // An ID that uniquely identifies a USB device.
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
        public string InstanceID;


        public override string ToString()
        {
            return string.Format("Vid: {0}\nPid: {1}\nMI: {2}\nInstanceID: {3}\n", Vid.ToString("X4") + "h", Pid.ToString("X4") + "h", MI.ToString("X2") + "h", InstanceID);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct KLST_DEVINFO_HANDLE : IKLIB_HANDLE
    {
        private readonly IntPtr mHandlePtr;

        public KLST_DEVINFO_HANDLE(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        public KLIB_HANDLE_TYPE HandleType
        {
            get { return KLIB_HANDLE_TYPE.LSTINFOK; }
        }

        public IntPtr GetContext()
        {
            return AllKFunctions.LibK_GetContext(mHandlePtr, HandleType);
        }

        public bool SetContext(IntPtr UserContext)
        {
            return AllKFunctions.LibK_SetContext(mHandlePtr, HandleType, UserContext);
        }

        public bool SetCleanupCallback(KLIB_HANDLE_CLEANUP_CB CleanupCallback)
        {
            return AllKFunctions.LibK_SetCleanupCallback(mHandlePtr, HandleType, CleanupCallback);
        }

        /// <summary>KLST_DEVINFO_MAP is used for calculating field offsets only</summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct KLST_DEVINFO_MAP
        {
            /// <Summary>Common usb device information</Summary>
            private readonly KLST_DEV_COMMON_INFO Common;

            /// <Summary>Driver id this device element is using</Summary>
            private readonly int DriverID;

            /// <Summary>Device interface GUID</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string DeviceInterfaceGUID;

            /// <Summary>Device instance ID.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string DeviceID;

            /// <Summary>Class GUID.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string ClassGUID;

            /// <Summary>Manufacturer name as specified in the INF file.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string Mfg;

            /// <Summary>Device description as specified in the INF file.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string DeviceDesc;

            /// <Summary>Driver service name.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string Service;

            /// <Summary>Unique identifier.</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string SymbolicLink;

            /// <Summary>physical device filename used with the Windows \c CreateFile()</Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string DevicePath;

            /// <Summary>libusb-win32 filter index id.</Summary>
            private readonly int LUsb0FilterIndex;

            /// <Summary>Indicates the devices connection state.</Summary>
            private readonly bool Connected;

            /// <Summary>Synchronization flags. (internal use only)</Summary>
            private readonly KLST_SYNC_FLAG SyncFlags;

            private readonly int BusNumber;

            private readonly int DeviceAddress;

            /// <Summary>
            ///     If the the device is serialized, represents the string value of \ref USB_DEVICE_DESCRIPTOR::iSerialNumber. For
            ///     Devices without a \b iSerialNumber, represents the unique \b InstanceID assigned by \b Windows.
            /// </Summary>
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
            private readonly string SerialNumber;
        }

        private static readonly int ofsCommon = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "Common").ToInt32();
        private static readonly int ofsDriverID = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DriverID").ToInt32();
        private static readonly int ofsDeviceInterfaceGUID = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DeviceInterfaceGUID").ToInt32();
        private static readonly int ofsDeviceID = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DeviceID").ToInt32();
        private static readonly int ofsClassGUID = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "ClassGUID").ToInt32();
        private static readonly int ofsMfg = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "Mfg").ToInt32();
        private static readonly int ofsDeviceDesc = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DeviceDesc").ToInt32();
        private static readonly int ofsService = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "Service").ToInt32();
        private static readonly int ofsSymbolicLink = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "SymbolicLink").ToInt32();
        private static readonly int ofsDevicePath = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DevicePath").ToInt32();
        private static readonly int ofsLUsb0FilterIndex = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "LUsb0FilterIndex").ToInt32();
        private static readonly int ofsConnected = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "Connected").ToInt32();
        private static readonly int ofsSyncFlags = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "SyncFlags").ToInt32();
        private static readonly int ofsBusNumber = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "BusNumber").ToInt32();
        private static readonly int ofsDeviceAddress = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "DeviceAddress").ToInt32();
        private static readonly int ofsSerialNumber = Marshal.OffsetOf(typeof(KLST_DEVINFO_MAP), "SerialNumber").ToInt32();


        /// <Summary>Common usb device information</Summary>
        public KLST_DEV_COMMON_INFO Common
        {
            get { return (KLST_DEV_COMMON_INFO) Marshal.PtrToStructure(new IntPtr(mHandlePtr.ToInt64() + ofsCommon), typeof(KLST_DEV_COMMON_INFO)); }
        }


        /// <Summary>Driver id this device element is using</Summary>
        public int DriverID
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsDriverID); }
        }


        /// <Summary>Device interface GUID</Summary>
        public string DeviceInterfaceGUID
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsDeviceInterfaceGUID)); }
        }


        /// <Summary>Device instance ID.</Summary>

        public string DeviceID
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsDeviceID)); }
        }


        /// <Summary>Class GUID.</Summary>
        public string ClassGUID
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsClassGUID)); }
        }


        /// <Summary>Manufacturer name as specified in the INF file.</Summary>
        public string Mfg
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsMfg)); }
        }


        /// <Summary>Device description as specified in the INF file.</Summary>
        public string DeviceDesc
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsDeviceDesc)); }
        }


        /// <Summary>Driver service name.</Summary>
        public string Service
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsService)); }
        }


        /// <Summary>Unique identifier.</Summary>
        public string SymbolicLink
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsSymbolicLink)); }
        }


        /// <Summary>physical device filename used with the Windows \c CreateFile()</Summary>
        public string DevicePath
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsDevicePath)); }
        }


        /// <Summary>libusb-win32 filter index id.</Summary>
        public int LUsb0FilterIndex
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsLUsb0FilterIndex); }
        }


        /// <Summary>Indicates the devices connection state.</Summary>
        public bool Connected
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsConnected) != 0; }
        }


        /// <Summary>Synchronization flags. (internal use only)</Summary>
        public KLST_SYNC_FLAG SyncFlags
        {
            get { return (KLST_SYNC_FLAG) Marshal.ReadInt32(mHandlePtr, ofsSyncFlags); }
        }


        public int BusNumber
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsBusNumber); }
        }


        public int DeviceAddress
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsDeviceAddress); }
        }


        /// <Summary>
        ///     If the the device is serialized, represents the string value of \ref USB_DEVICE_DESCRIPTOR::iSerialNumber. For
        ///     Devices without a \b iSerialNumber, represents the unique \b InstanceID assigned by \b Windows.
        /// </Summary>
        public string SerialNumber
        {
            get { return Marshal.PtrToStringAnsi(new IntPtr(mHandlePtr.ToInt64() + ofsSerialNumber)); }
        }


        public override string ToString()
        {
            return string.Format("DriverID: {0}\nDeviceInterfaceGUID: {1}\nDeviceID: {2}\nClassGUID: {3}\nMfg: {4}\nDeviceDesc: {5}\nService: {6}\nSymbolicLink: {7}\nDevicePath: {8}\nLUsb0FilterIndex: {9}\nConnected: {10}\nSyncFlags: {11}\nBusNumber: {12}\nDeviceAddress: {13}\nSerialNumber: {14}\n", DriverID, DeviceInterfaceGUID, DeviceID, ClassGUID, Mfg, DeviceDesc, Service, SymbolicLink, DevicePath, LUsb0FilterIndex, Connected, SyncFlags.ToString(), BusNumber, DeviceAddress, SerialNumber);
        }
    }

    /// <Summary>Device list/hot-plug pattern match structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Size = 1024)]
    public struct KLST_PATTERN_MATCH
    {
        /// <Summary>Pattern match a device instance id.</Summary>
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
        public string DeviceID;

        /// <Summary>Pattern match a device interface guid.</Summary>
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
        public string DeviceInterfaceGUID;

        /// <Summary>Pattern match a symbolic link.</Summary>
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
        public string ClassGUID;


        public override string ToString()
        {
            return string.Format("DeviceID: {0}\nDeviceInterfaceGUID: {1}\nClassGUID: {2}\n", DeviceID, DeviceInterfaceGUID, ClassGUID);
        }
    }

    /// <Summary>A structure representing the standard USB device descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_DEVICE_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>USB specification release number in binary-coded decimal.</Summary>
        public ushort bcdUSB;

        /// <Summary>USB-IF class code for the device</Summary>
        public byte bDeviceClass;

        /// <Summary>USB-IF subclass code for the device</Summary>
        public byte bDeviceSubClass;

        /// <Summary>USB-IF protocol code for the device</Summary>
        public byte bDeviceProtocol;

        /// <Summary>Maximum packet size for control endpoint 0</Summary>
        public byte bMaxPacketSize0;

        /// <Summary>USB-IF vendor ID</Summary>
        public ushort idVendor;

        /// <Summary>USB-IF product ID</Summary>
        public ushort idProduct;

        /// <Summary>Device release number in binary-coded decimal</Summary>
        public ushort bcdDevice;

        /// <Summary>Index of string descriptor describing manufacturer</Summary>
        public byte iManufacturer;

        /// <Summary>Index of string descriptor describing product</Summary>
        public byte iProduct;

        /// <Summary>Index of string descriptor containing device serial number</Summary>
        public byte iSerialNumber;

        /// <Summary>Number of possible configurations</Summary>
        public byte bNumConfigurations;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nbcdUSB: {2}\nbDeviceClass: {3}\nbDeviceSubClass: {4}\nbDeviceProtocol: {5}\nbMaxPacketSize0: {6}\nidVendor: {7}\nidProduct: {8}\nbcdDevice: {9}\niManufacturer: {10}\niProduct: {11}\niSerialNumber: {12}\nbNumConfigurations: {13}\n", bLength, bDescriptorType.ToString("X2") + "h", bcdUSB.ToString("X4") + "h", bDeviceClass.ToString("X2") + "h", bDeviceSubClass.ToString("X2") + "h", bDeviceProtocol.ToString("X2") + "h", bMaxPacketSize0, idVendor.ToString("X4") + "h", idProduct.ToString("X4") + "h", bcdDevice.ToString("X4") + "h", iManufacturer, iProduct, iSerialNumber, bNumConfigurations);
        }
    }

    /// <Summary>A structure representing the standard USB endpoint descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_ENDPOINT_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>The address of the endpoint described by this descriptor.</Summary>
        public byte bEndpointAddress;

        /// <Summary>Attributes which apply to the endpoint when it is configured using the bConfigurationValue.</Summary>
        public byte bmAttributes;

        /// <Summary>Maximum packet size this endpoint is capable of sending/receiving.</Summary>
        public ushort wMaxPacketSize;

        /// <Summary>Interval for polling endpoint for data transfers.</Summary>
        public byte bInterval;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nbEndpointAddress: {2}\nbmAttributes: {3}\nwMaxPacketSize: {4}\nbInterval: {5}\n", bLength, bDescriptorType.ToString("X2") + "h", bEndpointAddress.ToString("X2") + "h", bmAttributes.ToString("X2") + "h", wMaxPacketSize, bInterval);
        }
    }

    /// <Summary>BOS device capability descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_DEV_CAPABILITY_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Capability type</Summary>
        public byte bDevCapabilityType;

        /// <Summary>Capability Data</Summary>
    }

    /// <Summary>USB 3.0 and USB 2.0 LPM Binary Device Object Store (BOS).</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Length of this descriptor and all sub descriptors</Summary>
        public ushort wTotalLength;

        /// <Summary>Number of device capability descriptors</Summary>
        public byte bNumDeviceCaps;
    }

    /// <Summary>USB 2.0 Extension descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_USB_2_0_EXTENSION_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Capability type. See \ref BOS_CAPABILITY_TYPE</Summary>
        public byte bDevCapabilityType;

        /// <Summary>Bitmap encoding of supported device level features.</Summary>
        public uint bmAttributes;
    }

    /// <Summary>SuperSpeed Device Capability Descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_SS_USB_DEVICE_CAPABILITY_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Capability type. See \ref BOS_CAPABILITY_TYPE</Summary>
        public byte bDevCapabilityType;

        /// <Summary>Bitmap encoding of supported device level features.</Summary>
        public byte bmAttributes;

        /// <Summary>Bitmap encoding of the supported speeds.</Summary>
        public ushort wSpeedSupported;

        /// <Summary>The lowest speed at which all the functionality	supported by the device is available to the user</Summary>
        public byte bFunctionalitySupport;

        /// <Summary>U1 Device Exit Latency. Worst-case latency to transition from U1 to U0.</Summary>
        public byte bU1DevExitLat;

        /// <Summary>U2 Device Exit Latency. Worst-case latency to transition from U2 to U0.</Summary>
        public ushort bU2DevExitLat;
    }

    /// <Summary>Container ID Descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_CONTAINER_ID_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Capability type. See \ref BOS_CAPABILITY_TYPE</Summary>
        public byte bDevCapabilityType;

        // Reserved.
        public byte bReserved;

        /// <Summary>This is a 128-bit number that is used to uniquely identify the device instance across all modes of operation.</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
        public byte[] ContainerID;
    }

    /// <Summary>Platform specific capabilities</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_PLATFORM_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        // Capability type. See \ref BOS_CAPABILITY_TYPE
        public byte bDevCapabilityType;

        /// <Summary>Reserved</Summary>
        public byte bReserved;

        /// <Summary>A 128-bit number that uniquely identifies a platform-specific capability of the device.</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
        public byte[] PlatformCapabilityUUID;

        /// <Summary>Capability Data</Summary>
    }

    /// <Summary>This structure represents the windows version records that follow a BOS windows platform descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct BOS_WINDOWS_PLATFORM_VERSION
    {
        /// <Summary>Minimum version of Windows</Summary>
        public uint dwWindowsVersion;

        /// <Summary>The length, in bytes of the MS OS 2.0 descriptor set.</Summary>
        public ushort wMSOSDescriptorSetTotalLength;

        /// <Summary>Vendor defined code.</Summary>
        public byte bMS_VendorCode;

        /// <Summary>Alternate enumeration indicator.</Summary>
        public byte bAltEnumCode;
    }

    /// <Summary>Special Microsoft string descriptor used to indicate that a device supports Microsoft OS V1.0 descriptors.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_MSOSV1_STRING_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor. Shall always be 18 bytes</Summary>
        public byte bLength;

        /// <Summary>Descriptor type (0x03)</Summary>
        public byte bDescriptorType;

        /// <Summary>Microsoft signature. Shall always be "MSFT100"</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)]
        public byte[] qwSignature;

        /// <Summary>Vendor specific vendor code</Summary>
        public byte bMS_VendorCode;

        /// <Summary>Padding</Summary>
        public byte bPad;
    }
// !The extended compat ID OS descriptor has two components:

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV1_EXTENDED_COMPAT_ID_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of the complete extended compat ID descriptor</Summary>
        public uint dwLength;

        /// <Summary>The descriptor’s version number, in binary coded decimal (BCD) format</Summary>
        public ushort bcdVersion;

        /// <Summary>An index that identifies the particular OS feature descriptor</Summary>
        public ushort wIndex;

        /// <Summary>The number of custom property sections</Summary>
        public byte bCount;

        /// <Summary>Reserved</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 7)]
        public byte[] Rsvd;
    }

    /// <Summary>A function section defines the compatible ID and a subcompatible ID for a specified interface or function.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV1_FUNCTION_DESCRIPTOR
    {
        /// <Summary>The interface or function number</Summary>
        public byte bFirstInterfaceNumber;

        /// <Summary>Reserved</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
        public byte[] Rsvd1;

        /// <Summary>The function’s compatible ID</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] CompatibleID;

        /// <Summary>The function’s subcompatible ID</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] SubCompatibleID;

        /// <Summary>Reserved</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
        public byte[] Rsvd2;
    }
// !The extended properties OS descriptor is a Microsoft OS feature descriptor that can be used to store vendor-specific property data.

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV1_EXTENDED_PROP_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of the complete extended prop descriptor</Summary>
        public uint dwLength;

        /// <Summary>The descriptor’s version number, in binary coded decimal (BCD) format</Summary>
        public ushort bcdVersion;

        /// <Summary>The index for extended properties OS descriptors</Summary>
        public ushort wIndex;

        /// <Summary>The number of custom property sections that follow this header section</Summary>
        public ushort wCount;

        /// <Summary>Placeholder for \b wCount number of custom properties.  See \ref MSOSV1_CUSTOM_PROP_DESCRIPTOR and \ref MSOS_CUSTOM_PROP_ELEMENT</Summary>
    }

    /// <Summary>A custom property section contains the information for a single property</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV1_CUSTOM_PROP_DESCRIPTOR
    {
        /// <Summary>The size of this custom properties section</Summary>
        public uint dwSize;

        /// <Summary>The type of data associated with the section</Summary>
        public uint dwPropertyDataType;

        /// <Summary>Placeholder for variable length property name and data field. see \ref MSOS_CUSTOM_PROP_ELEMENT</Summary>
    }

    /// <Summary>
    ///     Helper structure for parsing a /ref MSOSV1_CUSTOM_PROP_DESCRIPTOR or a \ref
    ///     MSOSV2_FEATURE_REG_PROPERTY_DESCRIPTOR
    /// </Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOS_CUSTOM_PROP_ELEMENT
    {
        public ushort wPropertyNameLength;
        public IntPtr pPropertyName;
        public ushort wPropertyDataLength;
        public IntPtr pPropertyData;
    }

    /// <Summary>All MS OS V2.0 descriptors start with these two fields.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_COMMON_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor.</Summary>
        public ushort wLength;

        /// <Summary>See \ref MSOSV2_DESCRIPTOR_TYPE</Summary>
        public ushort wDescriptorType;
    }

    /// <Summary>Microsoft OS 2.0 descriptor set header</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_SET_HEADER_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this header. Shall be set to 10.</Summary>
        public ushort wLength;

        /// <Summary>\ref SET_HEADER_DESCRIPTOR</Summary>
        public ushort wDescriptorType;

        /// <Summary>Windows version.</Summary>
        public uint dwWindowsVersion;

        /// <Summary>
        ///     The size of entire MS OS 2.0 descriptor set. The value shall match the value in the descriptor set information
        ///     structure.  See \ref BOS_WINDOWS_PLATFORM_VERSION::wMSOSDescriptorSetTotalLength
        /// </Summary>
        public ushort wTotalLength;
    }

    /// <Summary>Microsoft OS 2.0 configuration subset header</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_SUBSET_HEADER_CONFIGURATION_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this subset header. Shall be set to 8.</Summary>
        public ushort wLength;

        /// <Summary>\ref SUBSET_HEADER_CONFIGURATION</Summary>
        public ushort wDescriptorType;

        /// <Summary>The configuration value for the USB configuration to which this subset applies.</Summary>
        public byte bConfigurationValue;

        /// <Summary>Reserved</Summary>
        public byte bReserved;

        /// <Summary>The size of entire configuration subset including this header.</Summary>
        public ushort wTotalLength;
    }

    /// <Summary>Microsoft OS 2.0 function subset header</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_SUBSET_HEADER_FUNCTION_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this subset header. Shall be set to 8.</Summary>
        public ushort wLength;

        /// <Summary>\ref SUBSET_HEADER_FUNCTION</Summary>
        public ushort wDescriptorType;

        /// <Summary>The interface number for the first interface of the function to which this subset applies.</Summary>
        public byte bFirstInterface;

        /// <Summary>Reserved</Summary>
        public byte bReserved;

        /// <Summary>The size of entire function subset including this header.</Summary>
        public ushort wSubsetLength;
    }

    /// <Summary>Microsoft OS 2.0 compatible ID descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_COMPATBLE_ID_DESCRIPTOR
    {
        /// <Summary>The length, bytes, of the compatible ID descriptor including value descriptors. Shall be set to 20.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_COMPATIBLE_ID</Summary>
        public ushort wDescriptorType;

        /// <Summary>Compatible ID String</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] CompatibleID;

        /// <Summary>Sub-compatible ID String</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] SubCompatibleID;
    }

    /// <Summary>Microsoft OS 2.0 registry property descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_REG_PROPERTY_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_REG_PROPERTY</Summary>
        public ushort wDescriptorType;

        /// <Summary>The type of data associated with the section</Summary>
        public ushort wPropertyDataType;

        /// <Summary>Placeholder for variable length property name and data field. see \ref MSOS_CUSTOM_PROP_ELEMENT</Summary>
    }

    /// <Summary>Microsoft OS 2.0 minimum USB resume time descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_MIN_RESUME_TIME_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor. Shall be set to 6.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_MIN_RESUME_TIME</Summary>
        public ushort wDescriptorType;

        /// <Summary>The number of milliseconds the device requires to recover from port resume. (Valid values are 0 to 10)</Summary>
        public byte bResumeRecoveryTime;

        /// <Summary>The number of milliseconds the device requires resume signaling to be asserted.  (Valid values 1 to 20)</Summary>
        public byte bResumeSignalingTime;
    }

    /// <Summary>Microsoft OS 2.0 model ID descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_MODEL_ID_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor. Shall be set to 20.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_MODEL_ID</Summary>
        public ushort wDescriptorType;

        /// <Summary>This is a 128-bit number that uniquely identifies a physical device.</Summary>
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
        public byte[] ModelID;
    }

    /// <Summary>Microsoft OS 2.0 CCGP device descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_CCGP_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor. Shall be set to 4.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_CCGP_DEVICE</Summary>
        public ushort wDescriptorType;
    }

    /// <Summary>Microsoft OS 2.0 vendor revision descriptor</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct MSOSV2_FEATURE_VENDOR_REVISION_DESCRIPTOR
    {
        /// <Summary>The length, in bytes, of this descriptor. Shall be set to 6.</Summary>
        public ushort wLength;

        /// <Summary>\ref FEATURE_VENDOR_REVISION</Summary>
        public ushort wDescriptorType;

        /// <Summary>Revision number associated with the descriptor set.</Summary>
        public ushort VendorRevision;
    }

    /// <Summary>A structure representing the standard USB configuration descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_CONFIGURATION_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Total length of data returned for this configuration</Summary>
        public ushort wTotalLength;

        /// <Summary>Number of interfaces supported by this configuration</Summary>
        public byte bNumInterfaces;

        /// <Summary>Identifier value for this configuration</Summary>
        public byte bConfigurationValue;

        /// <Summary>Index of string descriptor describing this configuration</Summary>
        public byte iConfiguration;

        /// <Summary>Configuration characteristics</Summary>
        public byte bmAttributes;

        /// <Summary>
        ///     Maximum power consumption of the USB device from this bus in this configuration when the device is fully
        ///     operation.
        /// </Summary>
        public byte MaxPower;

        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nwTotalLength: {2}\nbNumInterfaces: {3}\nbConfigurationValue: {4}\niConfiguration: {5}\nbmAttributes: {6}\nMaxPower: {7}\n", bLength, bDescriptorType.ToString("X2") + "h", wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration, bmAttributes.ToString("X2") + "h", MaxPower);
        }
    }

    /// <Summary>A structure representing the standard USB interface descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_INTERFACE_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Number of this interface</Summary>
        public byte bInterfaceNumber;

        /// <Summary>Value used to select this alternate setting for this interface</Summary>
        public byte bAlternateSetting;

        /// <Summary>Number of endpoints used by this interface (excluding the control endpoint)</Summary>
        public byte bNumEndpoints;

        /// <Summary>USB-IF class code for this interface</Summary>
        public byte bInterfaceClass;

        /// <Summary>USB-IF subclass code for this interface</Summary>
        public byte bInterfaceSubClass;

        /// <Summary>USB-IF protocol code for this interface</Summary>
        public byte bInterfaceProtocol;

        /// <Summary>Index of string descriptor describing this interface</Summary>
        public byte iInterface;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nbInterfaceNumber: {2}\nbAlternateSetting: {3}\nbNumEndpoints: {4}\nbInterfaceClass: {5}\nbInterfaceSubClass: {6}\nbInterfaceProtocol: {7}\niInterface: {8}\n", bLength, bDescriptorType.ToString("X2") + "h", bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass.ToString("X2") + "h", bInterfaceSubClass.ToString("X2") + "h", bInterfaceProtocol.ToString("X2") + "h", iInterface);
        }
    }

    /// <Summary>A structure representing the standard USB string descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
    public struct USB_STRING_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>Content of the string</Summary>
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = AllKConstants.KLST_STRING_MAX_LEN)]
        public string bString;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nbString: {2}\n", bLength, bDescriptorType.ToString("X2") + "h", bString);
        }
    }

    /// <Summary>A structure representing the common USB descriptor.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_COMMON_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\n", bLength, bDescriptorType.ToString("X2") + "h");
        }
    }

    /// <Summary>Allows hardware manufacturers to define groupings of interfaces.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
    public struct USB_INTERFACE_ASSOCIATION_DESCRIPTOR
    {
        /// <Summary>Size of this descriptor (in bytes)</Summary>
        public byte bLength;

        /// <Summary>Descriptor type</Summary>
        public byte bDescriptorType;

        /// <Summary>First interface number of the set of interfaces that follow this descriptor</Summary>
        public byte bFirstInterface;

        /// <Summary>The Number of interfaces follow this descriptor that are considered "associated"</Summary>
        public byte bInterfaceCount;

        /// <Summary>\c bInterfaceClass used for this associated interfaces</Summary>
        public byte bFunctionClass;

        /// <Summary>\c bInterfaceSubClass used for the associated interfaces</Summary>
        public byte bFunctionSubClass;

        /// <Summary>\c bInterfaceProtocol used for the associated interfaces</Summary>
        public byte bFunctionProtocol;

        /// <Summary>Index of string descriptor describing the associated interfaces</Summary>
        public byte iFunction;


        public override string ToString()
        {
            return string.Format("bLength: {0}\nbDescriptorType: {1}\nbFirstInterface: {2}\nbInterfaceCount: {3}\nbFunctionClass: {4}\nbFunctionSubClass: {5}\nbFunctionProtocol: {6}\niFunction: {7}\n", bLength, bDescriptorType.ToString("X2") + "h", bFirstInterface, bInterfaceCount, bFunctionClass.ToString("X2") + "h", bFunctionSubClass.ToString("X2") + "h", bFunctionProtocol.ToString("X2") + "h", iFunction);
        }
    }

    /// <Summary>USB core driver API information structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct KUSB_DRIVER_API_INFO
    {
        /// <Summary>\readonly Driver id of the driver api.</Summary>
        public int DriverID;

        /// <Summary>\readonly Number of valid functions contained in the driver API.</Summary>
        public int FunctionCount;


        public override string ToString()
        {
            return string.Format("DriverID: {0}\nFunctionCount: {1}\n", DriverID, FunctionCount);
        }
    }

    /// <Summary>Driver API function set structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Size = 512)]
    public struct KUSB_DRIVER_API
    {
        /// <Summary>Driver API information.</Summary>
        public KUSB_DRIVER_API_INFO Info;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_InitDelegate Init;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_FreeDelegate Free;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ClaimInterfaceDelegate ClaimInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ReleaseInterfaceDelegate ReleaseInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SetAltInterfaceDelegate SetAltInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetAltInterfaceDelegate GetAltInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetDescriptorDelegate GetDescriptor;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ControlTransferDelegate ControlTransfer;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SetPowerPolicyDelegate SetPowerPolicy;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetPowerPolicyDelegate GetPowerPolicy;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SetConfigurationDelegate SetConfiguration;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetConfigurationDelegate GetConfiguration;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ResetDeviceDelegate ResetDevice;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_InitializeDelegate Initialize;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SelectInterfaceDelegate SelectInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetAssociatedInterfaceDelegate GetAssociatedInterface;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_CloneDelegate Clone;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_QueryInterfaceSettingsDelegate QueryInterfaceSettings;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_QueryDeviceInformationDelegate QueryDeviceInformation;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SetCurrentAlternateSettingDelegate SetCurrentAlternateSetting;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetCurrentAlternateSettingDelegate GetCurrentAlternateSetting;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_QueryPipeDelegate QueryPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_SetPipePolicyDelegate SetPipePolicy;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetPipePolicyDelegate GetPipePolicy;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ReadPipeDelegate ReadPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_WritePipeDelegate WritePipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_ResetPipeDelegate ResetPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_AbortPipeDelegate AbortPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_FlushPipeDelegate FlushPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_IsoReadPipeDelegate IsoReadPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_IsoWritePipeDelegate IsoWritePipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetCurrentFrameNumberDelegate GetCurrentFrameNumber;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetOverlappedResultDelegate GetOverlappedResult;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetPropertyDelegate GetProperty;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_IsochReadPipeDelegate IsochReadPipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_IsochWritePipeDelegate IsochWritePipe;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_QueryPipeExDelegate QueryPipeEx;


        [MarshalAs(UnmanagedType.FunctionPtr)] public KUSB_GetSuperSpeedPipeCompanionDescriptorDelegate GetSuperSpeedPipeCompanionDescriptor;
    }

    /// <Summary>Hot plug parameter structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Size = 2048)]
    public struct KHOT_PARAMS
    {
        /// <Summary>Hot plug event window handle to send/post messages when notifications occur.</Summary>
        public IntPtr UserHwnd;

        /// <Summary>WM_USER message start offset used when sending/posting messages, See details.</Summary>
        public uint UserMessage;

        /// <Summary>Additional init/config parameters</Summary>
        public KHOT_FLAG Flags;

        /// <Summary>File pattern matches for restricting notifcations to a single/group or all supported usb devices.</Summary>
        public KLST_PATTERN_MATCH PatternMatch;

        /// <Summary>Hot plug event callback function invoked when notifications occur.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KHOT_PLUG_CB OnHotPlug;

        /// <Summary>\b WM_POWERBROADCAST event callback function invoked when a power-management event has occurred.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KHOT_POWER_BROADCAST_CB OnPowerBroadcast;


        public override string ToString()
        {
            return string.Format("UserHwnd: {0}\nUserMessage: {1}\nFlags: {2}\n", UserHwnd.ToString("X16") + "h", UserMessage.ToString("X8") + "h", Flags.ToString());
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct KSTM_XFER_CONTEXT
    {
        private readonly IntPtr mHandlePtr;

        public KSTM_XFER_CONTEXT(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        /// <summary>KSTM_XFER_CONTEXT_MAP is used for calculating field offsets only</summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct KSTM_XFER_CONTEXT_MAP
        {
            /// <Summary>Internal stream buffer.</Summary>
            private readonly IntPtr Buffer;

            /// <Summary>Size of internal stream buffer.</Summary>
            private readonly int BufferSize;

            /// <Summary>Number of bytes to write or number of bytes read.</Summary>
            private readonly int TransferLength;

            /// <Summary>User defined state.</Summary>
            private readonly IntPtr UserState;
        }

        private static readonly int ofsBuffer = Marshal.OffsetOf(typeof(KSTM_XFER_CONTEXT_MAP), "Buffer").ToInt32();
        private static readonly int ofsBufferSize = Marshal.OffsetOf(typeof(KSTM_XFER_CONTEXT_MAP), "BufferSize").ToInt32();
        private static readonly int ofsTransferLength = Marshal.OffsetOf(typeof(KSTM_XFER_CONTEXT_MAP), "TransferLength").ToInt32();
        private static readonly int ofsUserState = Marshal.OffsetOf(typeof(KSTM_XFER_CONTEXT_MAP), "UserState").ToInt32();


        /// <Summary>Internal stream buffer.</Summary>
        public IntPtr Buffer
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsBuffer); }
        }


        /// <Summary>Size of internal stream buffer.</Summary>
        public int BufferSize
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsBufferSize); }
        }


        /// <Summary>Number of bytes to write or number of bytes read.</Summary>
        public int TransferLength
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsTransferLength); }
        }


        /// <Summary>User defined state.</Summary>
        public IntPtr UserState
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsUserState); }

            set { Marshal.WriteIntPtr(mHandlePtr, ofsUserState, value); }
        }


        public override string ToString()
        {
            return string.Format("Buffer: {0}\nBufferSize: {1}\nTransferLength: {2}\nUserState: {3}\n", Buffer.ToString("X16") + "h", BufferSize, TransferLength, UserState.ToString("X16") + "h");
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct KSTM_INFO
    {
        private readonly IntPtr mHandlePtr;

        public KSTM_INFO(IntPtr Handle)
        {
            mHandlePtr = Handle;
        }

        public IntPtr Pointer
        {
            get { return mHandlePtr; }
        }

        /// <summary>KSTM_INFO_MAP is used for calculating field offsets only</summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct KSTM_INFO_MAP
        {
            /// <Summary>\ref KUSB_HANDLE this stream uses.</Summary>
            private readonly IntPtr UsbHandle;

            /// <Summary>This parameter corresponds to the bEndpointAddress field in the endpoint descriptor.</Summary>
            private readonly byte PipeID;

            /// <Summary>Maximum transfer read/write request allowed pending.</Summary>
            private readonly int MaxPendingTransfers;

            /// <Summary>Maximum transfer sage size.</Summary>
            private readonly int MaxTransferSize;

            /// <Summary>Maximum number of I/O request allowed pending.</Summary>
            private readonly int MaxPendingIO;

            /// <Summary>Populated with the endpoint descriptor for the specified \c PipeID.</Summary>
            private readonly USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;

            /// <Summary>Populated with the driver api for the specified \c UsbHandle.</Summary>
            private readonly KUSB_DRIVER_API DriverAPI;

            /// <Summary>Populated with the device file handle for the specified \c UsbHandle.</Summary>
            private readonly IntPtr DeviceHandle;

            /// <Summary>Stream handle.</Summary>
            private readonly IntPtr StreamHandle;

            /// <Summary>Stream info user defined state.</Summary>
            private readonly IntPtr UserState;
        }

        private static readonly int ofsUsbHandle = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "UsbHandle").ToInt32();
        private static readonly int ofsPipeID = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "PipeID").ToInt32();
        private static readonly int ofsMaxPendingTransfers = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "MaxPendingTransfers").ToInt32();
        private static readonly int ofsMaxTransferSize = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "MaxTransferSize").ToInt32();
        private static readonly int ofsMaxPendingIO = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "MaxPendingIO").ToInt32();
        private static readonly int ofsEndpointDescriptor = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "EndpointDescriptor").ToInt32();
        private static readonly int ofsDriverAPI = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "DriverAPI").ToInt32();
        private static readonly int ofsDeviceHandle = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "DeviceHandle").ToInt32();
        private static readonly int ofsStreamHandle = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "StreamHandle").ToInt32();
        private static readonly int ofsUserState = Marshal.OffsetOf(typeof(KSTM_INFO_MAP), "UserState").ToInt32();


        /// <Summary>\ref KUSB_HANDLE this stream uses.</Summary>
        public IntPtr UsbHandle
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsUsbHandle); }
        }


        /// <Summary>This parameter corresponds to the bEndpointAddress field in the endpoint descriptor.</Summary>
        public byte PipeID
        {
            get { return Marshal.ReadByte(mHandlePtr, ofsPipeID); }
        }


        /// <Summary>Maximum transfer read/write request allowed pending.</Summary>
        public int MaxPendingTransfers
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsMaxPendingTransfers); }
        }


        /// <Summary>Maximum transfer sage size.</Summary>
        public int MaxTransferSize
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsMaxTransferSize); }
        }


        /// <Summary>Maximum number of I/O request allowed pending.</Summary>
        public int MaxPendingIO
        {
            get { return Marshal.ReadInt32(mHandlePtr, ofsMaxPendingIO); }
        }


        /// <Summary>Populated with the endpoint descriptor for the specified \c PipeID.</Summary>
        public USB_ENDPOINT_DESCRIPTOR EndpointDescriptor
        {
            get { return (USB_ENDPOINT_DESCRIPTOR) Marshal.PtrToStructure(new IntPtr(mHandlePtr.ToInt64() + ofsEndpointDescriptor), typeof(USB_ENDPOINT_DESCRIPTOR)); }
        }


        /// <Summary>Populated with the driver api for the specified \c UsbHandle.</Summary>
        public KUSB_DRIVER_API DriverAPI
        {
            get { return (KUSB_DRIVER_API) Marshal.PtrToStructure(new IntPtr(mHandlePtr.ToInt64() + ofsDriverAPI), typeof(KUSB_DRIVER_API)); }
        }


        /// <Summary>Populated with the device file handle for the specified \c UsbHandle.</Summary>
        public IntPtr DeviceHandle
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsDeviceHandle); }
        }


        /// <Summary>Stream handle.</Summary>
        public IntPtr StreamHandle
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsStreamHandle); }
        }


        /// <Summary>Stream info user defined state.</Summary>
        public IntPtr UserState
        {
            get { return Marshal.ReadIntPtr(mHandlePtr, ofsUserState); }

            set { Marshal.WriteIntPtr(mHandlePtr, ofsUserState, value); }
        }


        public override string ToString()
        {
            return string.Format("UsbHandle: {0}\nPipeID: {1}\nMaxPendingTransfers: {2}\nMaxTransferSize: {3}\nMaxPendingIO: {4}\nDeviceHandle: {5}\nStreamHandle: {6}\nUserState: {7}\n", UsbHandle.ToString("X16") + "h", PipeID.ToString("X2") + "h", MaxPendingTransfers, MaxTransferSize, MaxPendingIO, DeviceHandle.ToString("X16") + "h", StreamHandle.ToString("X16") + "h", UserState.ToString("X16") + "h");
        }
    }

    /// <Summary>Stream callback structure.</Summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Size = 64)]
    public struct KSTM_CALLBACK
    {
        /// <Summary>Executed when a transfer error occurs.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_ERROR_CB Error;

        /// <Summary>Executed to submit a transfer.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_SUBMIT_CB Submit;

        /// <Summary>Executed when a valid transfer completes.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_COMPLETE_CB Complete;

        /// <Summary>Executed for every transfer context when the stream is started with \ref StmK_Start.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_STARTED_CB Started;

        /// <Summary>Executed for every transfer context when the stream is stopped with \ref StmK_Stop.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_STOPPED_CB Stopped;

        /// <Summary>Executed immediately after a transfer completes.</Summary>
        [MarshalAs(UnmanagedType.FunctionPtr)] public KSTM_BEFORE_COMPLETE_CB BeforeComplete;
    }

    #endregion

    #region Delegates

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KLIB_HANDLE_CLEANUP_CB([In] IntPtr Handle, KLIB_HANDLE_TYPE HandleType, IntPtr UserContext);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KISO_ENUM_PACKETS_CB(uint PacketIndex, [In] ref KISO_PACKET IsoPacket, IntPtr UserState);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KISOCH_ENUM_PACKETS_CB(uint PacketIndex, ref uint Offset, ref uint Length, ref uint Status, IntPtr UserState);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KLST_ENUM_DEVINFO_CB([In] KLST_HANDLE DeviceList, [In] KLST_DEVINFO_HANDLE DeviceInfo, IntPtr Context);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_InitDelegate([Out] out KUSB_HANDLE InterfaceHandle, [In] KLST_DEVINFO_HANDLE DevInfo);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_FreeDelegate([In] KUSB_HANDLE InterfaceHandle);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ClaimInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte NumberOrIndex, bool IsIndex);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ReleaseInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte NumberOrIndex, bool IsIndex);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SetAltInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte NumberOrIndex, bool IsIndex, byte AltSettingNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetAltInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte NumberOrIndex, bool IsIndex, out byte AltSettingNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetDescriptorDelegate([In] KUSB_HANDLE InterfaceHandle, byte DescriptorType, byte Index, ushort LanguageID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ControlTransferDelegate([In] KUSB_HANDLE InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SetPowerPolicyDelegate([In] KUSB_HANDLE InterfaceHandle, uint PolicyType, uint ValueLength, IntPtr Value);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetPowerPolicyDelegate([In] KUSB_HANDLE InterfaceHandle, uint PolicyType, ref uint ValueLength, IntPtr Value);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SetConfigurationDelegate([In] KUSB_HANDLE InterfaceHandle, byte ConfigurationNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetConfigurationDelegate([In] KUSB_HANDLE InterfaceHandle, out byte ConfigurationNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ResetDeviceDelegate([In] KUSB_HANDLE InterfaceHandle);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_InitializeDelegate(IntPtr DeviceHandle, [Out] out KUSB_HANDLE InterfaceHandle);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SelectInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte NumberOrIndex, bool IsIndex);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetAssociatedInterfaceDelegate([In] KUSB_HANDLE InterfaceHandle, byte AssociatedInterfaceIndex, [Out] out KUSB_HANDLE AssociatedInterfaceHandle);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_CloneDelegate([In] KUSB_HANDLE InterfaceHandle, [Out] out KUSB_HANDLE DstInterfaceHandle);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_QueryInterfaceSettingsDelegate([In] KUSB_HANDLE InterfaceHandle, byte AltSettingIndex, [Out] out USB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_QueryDeviceInformationDelegate([In] KUSB_HANDLE InterfaceHandle, uint InformationType, ref uint BufferLength, IntPtr Buffer);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SetCurrentAlternateSettingDelegate([In] KUSB_HANDLE InterfaceHandle, byte AltSettingNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetCurrentAlternateSettingDelegate([In] KUSB_HANDLE InterfaceHandle, out byte AltSettingNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_QueryPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte AltSettingNumber, byte PipeIndex, [Out] out WINUSB_PIPE_INFORMATION PipeInformation);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_QueryPipeExDelegate([In] KUSB_HANDLE InterfaceHandle, byte AlternateSettingNumber, byte PipeIndex, [Out] out WINUSB_PIPE_INFORMATION_EX PipeInformationEx);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetSuperSpeedPipeCompanionDescriptorDelegate([In] KUSB_HANDLE Handle, byte AltSettingNumber, byte PipeIndex, [Out] out USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR PipeCompanionDescriptor);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_SetPipePolicyDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, uint PolicyType, uint ValueLength, IntPtr Value);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetPipePolicyDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, uint PolicyType, ref uint ValueLength, IntPtr Value);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ReadPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_WritePipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_ResetPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_AbortPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_FlushPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_IsoReadPipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, IntPtr Buffer, uint BufferLength, IntPtr Overlapped, [In] KISO_CONTEXT IsoContext);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_IsoWritePipeDelegate([In] KUSB_HANDLE InterfaceHandle, byte PipeID, IntPtr Buffer, uint BufferLength, IntPtr Overlapped, [In] KISO_CONTEXT IsoContext);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetCurrentFrameNumberDelegate([In] KUSB_HANDLE InterfaceHandle, out uint FrameNumber);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetOverlappedResultDelegate([In] KUSB_HANDLE InterfaceHandle, IntPtr Overlapped, out uint lpNumberOfBytesTransferred, bool bWait);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_GetPropertyDelegate([In] KUSB_HANDLE InterfaceHandle, KUSB_PROPERTY PropertyType, ref uint PropertySize, IntPtr Value);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_IsochReadPipeDelegate([In] KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate bool KUSB_IsochWritePipeDelegate([In] KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate void KHOT_PLUG_CB([In] KHOT_HANDLE HotHandle, [In] KLST_DEVINFO_HANDLE DeviceInfo, KLST_SYNC_FLAG PlugType);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate void KHOT_POWER_BROADCAST_CB([In] KHOT_HANDLE HotHandle, [In] KLST_DEVINFO_HANDLE DeviceInfo, uint PbtEvent);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KSTM_ERROR_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex, int ErrorCode);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KSTM_SUBMIT_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex, IntPtr Overlapped);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KSTM_STARTED_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KSTM_STOPPED_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate int KSTM_COMPLETE_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex, int ErrorCode);

    [UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Ansi, SetLastError = true)]
    public delegate KSTM_COMPLETE_RESULT KSTM_BEFORE_COMPLETE_CB([In] KSTM_INFO StreamInfo, [In] KSTM_XFER_CONTEXT XferContext, int XferContextIndex, ref int ErrorCode);

    #endregion

    public class LstK : IDisposable
    {
        protected bool mbDisposed;
        protected KLST_HANDLE mHandleStruct;

        protected LstK()
        {
        }

        /// <Summary>Initializes a new usb device list containing all supported devices.</Summary>
        public LstK(KLST_FLAG Flags)
        {
            bool success = AllKFunctions.LstK_Init(out mHandleStruct, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <Summary>Initializes a new usb device list containing only devices matching a specific class GUID.</Summary>
        public LstK(KLST_FLAG Flags, ref KLST_PATTERN_MATCH PatternMatch)
        {
            bool success = AllKFunctions.LstK_InitEx(out mHandleStruct, Flags, ref PatternMatch);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KLST_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~LstK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.LstK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KLST_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Initializes a new usb device list containing all supported devices.</Summary>
        protected bool Init(KLST_FLAG Flags)
        {
            bool success = AllKFunctions.LstK_Init(out mHandleStruct, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Initializes a new usb device list containing only devices matching a specific class GUID.</Summary>
        protected bool InitEx(KLST_FLAG Flags, ref KLST_PATTERN_MATCH PatternMatch)
        {
            bool success = AllKFunctions.LstK_InitEx(out mHandleStruct, Flags, ref PatternMatch);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Enumerates \ref KLST_DEVINFO elements of a \ref KLST_HANDLE.</Summary>
        public virtual bool Enumerate(KLST_ENUM_DEVINFO_CB EnumDevListCB, IntPtr Context)
        {
            return AllKFunctions.LstK_Enumerate(mHandleStruct, EnumDevListCB, Context);
        }

        /// <Summary>Gets the \ref KLST_DEVINFO element for the current position.</Summary>
        public virtual bool Current(out KLST_DEVINFO_HANDLE DeviceInfo)
        {
            return AllKFunctions.LstK_Current(mHandleStruct, out DeviceInfo);
        }

        /// <Summary>Advances the device list current \ref KLST_DEVINFO position.</Summary>
        public virtual bool MoveNext(out KLST_DEVINFO_HANDLE DeviceInfo)
        {
            return AllKFunctions.LstK_MoveNext(mHandleStruct, out DeviceInfo);
        }

        /// <Summary>Sets the device list to its initial position, which is before the first element in the list.</Summary>
        public virtual void MoveReset()
        {
            AllKFunctions.LstK_MoveReset(mHandleStruct);
        }

        /// <Summary>Find a device by vendor and product id</Summary>
        public virtual bool FindByVidPid(int Vid, int Pid, out KLST_DEVINFO_HANDLE DeviceInfo)
        {
            return AllKFunctions.LstK_FindByVidPid(mHandleStruct, Vid, Pid, out DeviceInfo);
        }

        /// <Summary>Counts the number of device info elements in a device list.</Summary>
        public virtual bool Count(ref uint Count)
        {
            return AllKFunctions.LstK_Count(mHandleStruct, ref Count);
        }
    }

    public class HotK : IDisposable
    {
        protected bool mbDisposed;
        protected KHOT_HANDLE mHandleStruct;

        protected HotK()
        {
        }

        /// <Summary>Creates a new hot-plug handle for USB device arrival/removal event monitoring.</Summary>
        public HotK(ref KHOT_PARAMS InitParams)
        {
            bool success = AllKFunctions.HotK_Init(out mHandleStruct, ref InitParams);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KHOT_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~HotK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.HotK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KHOT_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Creates a new hot-plug handle for USB device arrival/removal event monitoring.</Summary>
        protected bool Init(ref KHOT_PARAMS InitParams)
        {
            bool success = AllKFunctions.HotK_Init(out mHandleStruct, ref InitParams);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Frees all hot-plug handles initialized with \ref HotK_Init.</Summary>
        public static void FreeAll()
        {
            AllKFunctions.HotK_FreeAll();
        }
    }

    public class UsbK : IDisposable
    {
        protected KUSB_DRIVER_API driverAPI;
        protected bool mbDisposed;
        protected KUSB_HANDLE mHandleStruct;

        protected UsbK()
        {
        }

        /// <Summary>Creates/opens a libusbK interface handle from the device list. This is a preferred method.</Summary>
        public UsbK(KLST_DEVINFO_HANDLE DevInfo)
        {
            bool success = AllKFunctions.LibK_LoadDriverAPI(out driverAPI, DevInfo.DriverID);

            if (!success) throw new Exception(string.Format("{0} failed loading Driver API. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            success = driverAPI.Init(out mHandleStruct, DevInfo);

            if (!success)
                throw new Exception(string.Format("{0} failed initializing usb device. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <Summary>Creates a libusbK handle for the device specified by a file handle.</Summary>
        public UsbK(IntPtr DeviceHandle, KUSB_DRVID driverID)
        {
            bool success = AllKFunctions.LibK_LoadDriverAPI(out driverAPI, (int) driverID);

            if (!success) throw new Exception(string.Format("{0} failed loading Driver API. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            success = driverAPI.Initialize(DeviceHandle, out mHandleStruct);

            if (!success)
                throw new Exception(string.Format("{0} failed initializing usb device. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KUSB_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~UsbK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.UsbK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KUSB_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Creates/opens a libusbK interface handle from the device list. This is a preferred method.</Summary>
        protected bool Init(KLST_DEVINFO_HANDLE DevInfo)
        {
            bool success = AllKFunctions.LibK_LoadDriverAPI(out driverAPI, DevInfo.DriverID);

            if (!success) throw new Exception(string.Format("{0} failed loading Driver API. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            success = driverAPI.Init(out mHandleStruct, DevInfo);

            if (!success)
                throw new Exception(string.Format("{0} failed initializing usb device. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Claims the specified interface by number or index.</Summary>
        public virtual bool ClaimInterface(byte NumberOrIndex, bool IsIndex)
        {
            return driverAPI.ClaimInterface(mHandleStruct, NumberOrIndex, IsIndex);
        }

        /// <Summary>Releases the specified interface by number or index.</Summary>
        public virtual bool ReleaseInterface(byte NumberOrIndex, bool IsIndex)
        {
            return driverAPI.ReleaseInterface(mHandleStruct, NumberOrIndex, IsIndex);
        }

        /// <Summary>Sets the alternate setting of the specified interface.</Summary>
        public virtual bool SetAltInterface(byte NumberOrIndex, bool IsIndex, byte AltSettingNumber)
        {
            return driverAPI.SetAltInterface(mHandleStruct, NumberOrIndex, IsIndex, AltSettingNumber);
        }

        /// <Summary>Gets the alternate setting for the specified interface.</Summary>
        public virtual bool GetAltInterface(byte NumberOrIndex, bool IsIndex, out byte AltSettingNumber)
        {
            return driverAPI.GetAltInterface(mHandleStruct, NumberOrIndex, IsIndex, out AltSettingNumber);
        }

        /// <Summary>Gets the requested descriptor. This is a synchronous operation.</Summary>
        public virtual bool GetDescriptor(byte DescriptorType, byte Index, int LanguageID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred)
        {
            return driverAPI.GetDescriptor(mHandleStruct, DescriptorType, Index, (ushort) LanguageID, Buffer, BufferLength, out LengthTransferred);
        }

        /// <Summary>Gets the requested descriptor. This is a synchronous operation.</Summary>
        public virtual bool GetDescriptor(byte DescriptorType, byte Index, int LanguageID, Array Buffer, uint BufferLength, out uint LengthTransferred)
        {
            return driverAPI.GetDescriptor(mHandleStruct, DescriptorType, Index, (ushort) LanguageID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred);
        }

        /// <Summary>Transmits control data over a default control endpoint.</Summary>
        public virtual bool ControlTransfer(WINUSB_SETUP_PACKET SetupPacket, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.ControlTransfer(mHandleStruct, SetupPacket, Buffer, BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Transmits control data over a default control endpoint.</Summary>
        public virtual bool ControlTransfer(WINUSB_SETUP_PACKET SetupPacket, Array Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.ControlTransfer(mHandleStruct, SetupPacket, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Transmits control data over a default control endpoint.</Summary>
        public virtual bool ControlTransfer(WINUSB_SETUP_PACKET SetupPacket, Array Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.ControlTransfer(mHandleStruct, SetupPacket, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Transmits control data over a default control endpoint.</Summary>
        public virtual bool ControlTransfer(WINUSB_SETUP_PACKET SetupPacket, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.ControlTransfer(mHandleStruct, SetupPacket, Buffer, BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Sets the power policy for a device.</Summary>
        public virtual bool SetPowerPolicy(uint PolicyType, uint ValueLength, IntPtr Value)
        {
            return driverAPI.SetPowerPolicy(mHandleStruct, PolicyType, ValueLength, Value);
        }

        /// <Summary>Sets the power policy for a device.</Summary>
        public virtual bool SetPowerPolicy(uint PolicyType, uint ValueLength, Array Value)
        {
            return driverAPI.SetPowerPolicy(mHandleStruct, PolicyType, ValueLength, Marshal.UnsafeAddrOfPinnedArrayElement(Value, 0));
        }

        /// <Summary>Gets the power policy for a device.</Summary>
        public virtual bool GetPowerPolicy(uint PolicyType, ref uint ValueLength, IntPtr Value)
        {
            return driverAPI.GetPowerPolicy(mHandleStruct, PolicyType, ref ValueLength, Value);
        }

        /// <Summary>Gets the power policy for a device.</Summary>
        public virtual bool GetPowerPolicy(uint PolicyType, ref uint ValueLength, Array Value)
        {
            return driverAPI.GetPowerPolicy(mHandleStruct, PolicyType, ref ValueLength, Marshal.UnsafeAddrOfPinnedArrayElement(Value, 0));
        }

        /// <Summary>Sets the device configuration number.</Summary>
        public virtual bool SetConfiguration(byte ConfigurationNumber)
        {
            return driverAPI.SetConfiguration(mHandleStruct, ConfigurationNumber);
        }

        /// <Summary>Gets the device current configuration number.</Summary>
        public virtual bool GetConfiguration(out byte ConfigurationNumber)
        {
            return driverAPI.GetConfiguration(mHandleStruct, out ConfigurationNumber);
        }

        /// <Summary>Resets the usb device of the specified interface handle. (port cycle).</Summary>
        public virtual bool ResetDevice()
        {
            return driverAPI.ResetDevice(mHandleStruct);
        }

        /// <Summary>Creates a libusbK handle for the device specified by a file handle.</Summary>
        protected bool Initialize(IntPtr DeviceHandle, KUSB_DRVID driverID)
        {
            bool success = AllKFunctions.LibK_LoadDriverAPI(out driverAPI, (int) driverID);

            if (!success) throw new Exception(string.Format("{0} failed loading Driver API. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            success = driverAPI.Initialize(DeviceHandle, out mHandleStruct);

            if (!success)
                throw new Exception(string.Format("{0} failed initializing usb device. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Selects the specified interface by number or index as the current interface.</Summary>
        public virtual bool SelectInterface(byte NumberOrIndex, bool IsIndex)
        {
            return driverAPI.SelectInterface(mHandleStruct, NumberOrIndex, IsIndex);
        }

        /// <Summary>Retrieves a handle for an associated interface.</Summary>
        public virtual bool GetAssociatedInterface(byte AssociatedInterfaceIndex, out KUSB_HANDLE AssociatedInterfaceHandle)
        {
            return driverAPI.GetAssociatedInterface(mHandleStruct, AssociatedInterfaceIndex, out AssociatedInterfaceHandle);
        }

        /// <Summary>Clones the specified interface handle.</Summary>
        public virtual bool Clone(out KUSB_HANDLE DstInterfaceHandle)
        {
            return driverAPI.Clone(mHandleStruct, out DstInterfaceHandle);
        }

        /// <Summary>
        ///     Retrieves the interface descriptor for the specified alternate interface settings for a particular interface
        ///     handle.
        /// </Summary>
        public virtual bool QueryInterfaceSettings(byte AltSettingIndex, out USB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor)
        {
            return driverAPI.QueryInterfaceSettings(mHandleStruct, AltSettingIndex, out UsbAltInterfaceDescriptor);
        }

        /// <Summary>Retrieves information about the physical device that is associated with a libusbK handle.</Summary>
        public virtual bool QueryDeviceInformation(uint InformationType, ref uint BufferLength, IntPtr Buffer)
        {
            return driverAPI.QueryDeviceInformation(mHandleStruct, InformationType, ref BufferLength, Buffer);
        }

        /// <Summary>Retrieves information about the physical device that is associated with a libusbK handle.</Summary>
        public virtual bool QueryDeviceInformation(uint InformationType, ref uint BufferLength, Array Buffer)
        {
            return driverAPI.QueryDeviceInformation(mHandleStruct, InformationType, ref BufferLength, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0));
        }

        /// <Summary>Sets the alternate setting of an interface.</Summary>
        public virtual bool SetCurrentAlternateSetting(byte AltSettingNumber)
        {
            return driverAPI.SetCurrentAlternateSetting(mHandleStruct, AltSettingNumber);
        }

        /// <Summary>Gets the current alternate interface setting for an interface.</Summary>
        public virtual bool GetCurrentAlternateSetting(out byte AltSettingNumber)
        {
            return driverAPI.GetCurrentAlternateSetting(mHandleStruct, out AltSettingNumber);
        }

        /// <Summary>Retrieves information about a pipe that is associated with an interface.</Summary>
        public virtual bool QueryPipe(byte AltSettingNumber, byte PipeIndex, out WINUSB_PIPE_INFORMATION PipeInformation)
        {
            return driverAPI.QueryPipe(mHandleStruct, AltSettingNumber, PipeIndex, out PipeInformation);
        }

        /// <Summary>Retrieves information about a pipe that is associated with an interface.</Summary>
        public virtual bool QueryPipeEx(byte AltSettingNumber, byte PipeIndex, out WINUSB_PIPE_INFORMATION_EX PipeInformationEx)
        {
            return driverAPI.QueryPipeEx(mHandleStruct, AltSettingNumber, PipeIndex, out PipeInformationEx);
        }

        /// <Summary>Retrieves a pipes super speed endpoint companion descriptor associated with an interface.</Summary>
        public virtual bool GetSuperSpeedPipeCompanionDescriptor(byte AltSettingNumber, byte PipeIndex, out USB_SUPERSPEED_ENDPOINT_COMPANION_DESCRIPTOR PipeCompanionDescriptor)
        {
            return driverAPI.GetSuperSpeedPipeCompanionDescriptor(mHandleStruct, AltSettingNumber, PipeIndex, out PipeCompanionDescriptor);
        }

        /// <Summary>
        ///     Sets the policy for a specific pipe associated with an endpoint on the device. This is a synchronous
        ///     operation.
        /// </Summary>
        public virtual bool SetPipePolicy(byte PipeID, uint PolicyType, uint ValueLength, IntPtr Value)
        {
            return driverAPI.SetPipePolicy(mHandleStruct, PipeID, PolicyType, ValueLength, Value);
        }

        /// <Summary>
        ///     Sets the policy for a specific pipe associated with an endpoint on the device. This is a synchronous
        ///     operation.
        /// </Summary>
        public virtual bool SetPipePolicy(byte PipeID, uint PolicyType, uint ValueLength, Array Value)
        {
            return driverAPI.SetPipePolicy(mHandleStruct, PipeID, PolicyType, ValueLength, Marshal.UnsafeAddrOfPinnedArrayElement(Value, 0));
        }

        /// <Summary>Gets the policy for a specific pipe (endpoint).</Summary>
        public virtual bool GetPipePolicy(byte PipeID, uint PolicyType, ref uint ValueLength, IntPtr Value)
        {
            return driverAPI.GetPipePolicy(mHandleStruct, PipeID, PolicyType, ref ValueLength, Value);
        }

        /// <Summary>Gets the policy for a specific pipe (endpoint).</Summary>
        public virtual bool GetPipePolicy(byte PipeID, uint PolicyType, ref uint ValueLength, Array Value)
        {
            return driverAPI.GetPipePolicy(mHandleStruct, PipeID, PolicyType, ref ValueLength, Marshal.UnsafeAddrOfPinnedArrayElement(Value, 0));
        }

        /// <Summary>Reads data from the specified pipe.</Summary>
        public virtual bool ReadPipe(byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.ReadPipe(mHandleStruct, PipeID, Buffer, BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Reads data from the specified pipe.</Summary>
        public virtual bool ReadPipe(byte PipeID, Array Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.ReadPipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Reads data from the specified pipe.</Summary>
        public virtual bool ReadPipe(byte PipeID, Array Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.ReadPipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Reads data from the specified pipe.</Summary>
        public virtual bool ReadPipe(byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.ReadPipe(mHandleStruct, PipeID, Buffer, BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Writes data to a pipe.</Summary>
        public virtual bool WritePipe(byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.WritePipe(mHandleStruct, PipeID, Buffer, BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Writes data to a pipe.</Summary>
        public virtual bool WritePipe(byte PipeID, Array Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped)
        {
            return driverAPI.WritePipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped);
        }

        /// <Summary>Writes data to a pipe.</Summary>
        public virtual bool WritePipe(byte PipeID, Array Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.WritePipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Writes data to a pipe.</Summary>
        public virtual bool WritePipe(byte PipeID, IntPtr Buffer, uint BufferLength, out uint LengthTransferred, KOVL_HANDLE Overlapped)
        {
            return driverAPI.WritePipe(mHandleStruct, PipeID, Buffer, BufferLength, out LengthTransferred, Overlapped.Pointer);
        }

        /// <Summary>Resets the data toggle and clears the stall condition on a pipe.</Summary>
        public virtual bool ResetPipe(byte PipeID)
        {
            return driverAPI.ResetPipe(mHandleStruct, PipeID);
        }

        /// <Summary>Aborts all of the pending transfers for a pipe.</Summary>
        public virtual bool AbortPipe(byte PipeID)
        {
            return driverAPI.AbortPipe(mHandleStruct, PipeID);
        }

        /// <Summary>Discards any data that is cached in a pipe.</Summary>
        public virtual bool FlushPipe(byte PipeID)
        {
            return driverAPI.FlushPipe(mHandleStruct, PipeID);
        }

        /// <Summary>Reads from an isochronous pipe.</Summary>
        public virtual bool IsoReadPipe(byte PipeID, IntPtr Buffer, uint BufferLength, IntPtr Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoReadPipe(mHandleStruct, PipeID, Buffer, BufferLength, Overlapped, IsoContext);
        }

        /// <Summary>Reads from an isochronous pipe.</Summary>
        public virtual bool IsoReadPipe(byte PipeID, Array Buffer, uint BufferLength, IntPtr Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoReadPipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, Overlapped, IsoContext);
        }

        /// <Summary>Reads from an isochronous pipe.</Summary>
        public virtual bool IsoReadPipe(byte PipeID, Array Buffer, uint BufferLength, KOVL_HANDLE Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoReadPipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, Overlapped.Pointer, IsoContext);
        }

        /// <Summary>Reads from an isochronous pipe.</Summary>
        public virtual bool IsoReadPipe(byte PipeID, IntPtr Buffer, uint BufferLength, KOVL_HANDLE Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoReadPipe(mHandleStruct, PipeID, Buffer, BufferLength, Overlapped.Pointer, IsoContext);
        }

        /// <Summary>Writes to an isochronous pipe.</Summary>
        public virtual bool IsoWritePipe(byte PipeID, IntPtr Buffer, uint BufferLength, IntPtr Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoWritePipe(mHandleStruct, PipeID, Buffer, BufferLength, Overlapped, IsoContext);
        }

        /// <Summary>Writes to an isochronous pipe.</Summary>
        public virtual bool IsoWritePipe(byte PipeID, Array Buffer, uint BufferLength, IntPtr Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoWritePipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, Overlapped, IsoContext);
        }

        /// <Summary>Writes to an isochronous pipe.</Summary>
        public virtual bool IsoWritePipe(byte PipeID, Array Buffer, uint BufferLength, KOVL_HANDLE Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoWritePipe(mHandleStruct, PipeID, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), BufferLength, Overlapped.Pointer, IsoContext);
        }

        /// <Summary>Writes to an isochronous pipe.</Summary>
        public virtual bool IsoWritePipe(byte PipeID, IntPtr Buffer, uint BufferLength, KOVL_HANDLE Overlapped, KISO_CONTEXT IsoContext)
        {
            return driverAPI.IsoWritePipe(mHandleStruct, PipeID, Buffer, BufferLength, Overlapped.Pointer, IsoContext);
        }

        /// <Summary>Retrieves the current USB frame number.</Summary>
        public virtual bool GetCurrentFrameNumber(out uint FrameNumber)
        {
            return driverAPI.GetCurrentFrameNumber(mHandleStruct, out FrameNumber);
        }

        /// <Summary>Reads from an isochronous pipe. Supports LibusbK or WinUsb</Summary>
        public virtual bool IsochReadPipe(KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, IntPtr Overlapped)
        {
            return driverAPI.IsochReadPipe(IsochHandle, DataLength, ref FrameNumber, NumberOfPackets, Overlapped);
        }

        /// <Summary>Reads from an isochronous pipe. Supports LibusbK or WinUsb</Summary>
        public virtual bool IsochReadPipe(KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, KOVL_HANDLE Overlapped)
        {
            return driverAPI.IsochReadPipe(IsochHandle, DataLength, ref FrameNumber, NumberOfPackets, Overlapped.Pointer);
        }

        /// <Summary>Writes to an isochronous pipe. Supports LibusbK or WinUsb</Summary>
        public virtual bool IsochWritePipe(KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, IntPtr Overlapped)
        {
            return driverAPI.IsochWritePipe(IsochHandle, DataLength, ref FrameNumber, NumberOfPackets, Overlapped);
        }

        /// <Summary>Writes to an isochronous pipe. Supports LibusbK or WinUsb</Summary>
        public virtual bool IsochWritePipe(KISOCH_HANDLE IsochHandle, uint DataLength, ref uint FrameNumber, uint NumberOfPackets, KOVL_HANDLE Overlapped)
        {
            return driverAPI.IsochWritePipe(IsochHandle, DataLength, ref FrameNumber, NumberOfPackets, Overlapped.Pointer);
        }

        /// <Summary>Retrieves the results of an overlapped operation on the specified libusbK handle.</Summary>
        public virtual bool GetOverlappedResult(IntPtr Overlapped, out uint lpNumberOfBytesTransferred, bool bWait)
        {
            return driverAPI.GetOverlappedResult(mHandleStruct, Overlapped, out lpNumberOfBytesTransferred, bWait);
        }

        /// <Summary>Retrieves the results of an overlapped operation on the specified libusbK handle.</Summary>
        public virtual bool GetOverlappedResult(KOVL_HANDLE Overlapped, out uint lpNumberOfBytesTransferred, bool bWait)
        {
            return driverAPI.GetOverlappedResult(mHandleStruct, Overlapped.Pointer, out lpNumberOfBytesTransferred, bWait);
        }

        /// <Summary>Gets a USB device (driver specific) property from usb handle.</Summary>
        public virtual bool GetProperty(KUSB_PROPERTY PropertyType, ref uint PropertySize, IntPtr Value)
        {
            return driverAPI.GetProperty(mHandleStruct, PropertyType, ref PropertySize, Value);
        }

        /// <Summary>Gets a USB device (driver specific) property from usb handle.</Summary>
        public virtual bool GetProperty(KUSB_PROPERTY PropertyType, ref uint PropertySize, Array Value)
        {
            return driverAPI.GetProperty(mHandleStruct, PropertyType, ref PropertySize, Marshal.UnsafeAddrOfPinnedArrayElement(Value, 0));
        }
    }

    public class OvlK : IDisposable
    {
        protected bool mbDisposed;
        protected KOVL_POOL_HANDLE mHandleStruct;

        protected OvlK()
        {
        }

        /// <Summary>Creates a new overlapped pool.</Summary>
        public OvlK(KUSB_HANDLE UsbHandle, int MaxOverlappedCount, KOVL_POOL_FLAG Flags)
        {
            bool success = AllKFunctions.OvlK_Init(out mHandleStruct, UsbHandle, MaxOverlappedCount, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KOVL_POOL_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~OvlK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.OvlK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KOVL_POOL_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Gets a preallocated \c OverlappedK structure from the specified/default pool.</Summary>
        public virtual bool Acquire(out KOVL_HANDLE OverlappedK)
        {
            return AllKFunctions.OvlK_Acquire(out OverlappedK, mHandleStruct);
        }

        /// <Summary>Returns an \c OverlappedK structure to it's pool.</Summary>
        public static bool Release(KOVL_HANDLE OverlappedK)
        {
            return AllKFunctions.OvlK_Release(OverlappedK);
        }

        /// <Summary>Creates a new overlapped pool.</Summary>
        protected bool Init(KUSB_HANDLE UsbHandle, int MaxOverlappedCount, KOVL_POOL_FLAG Flags)
        {
            bool success = AllKFunctions.OvlK_Init(out mHandleStruct, UsbHandle, MaxOverlappedCount, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Returns the internal event handle used to signal IO operations.</Summary>
        public static IntPtr GetEventHandle(KOVL_HANDLE OverlappedK)
        {
            return AllKFunctions.OvlK_GetEventHandle(OverlappedK);
        }

        /// <Summary>Waits for overlapped I/O completion, and performs actions specified in \c WaitFlags.</Summary>
        public static bool Wait(KOVL_HANDLE OverlappedK, int TimeoutMS, KOVL_WAIT_FLAG WaitFlags, out uint TransferredLength)
        {
            return AllKFunctions.OvlK_Wait(OverlappedK, TimeoutMS, WaitFlags, out TransferredLength);
        }

        /// <Summary>
        ///     Waits for overlapped I/O completion on the oldest acquired OverlappedK handle and performs actions specified
        ///     in \c WaitFlags.
        /// </Summary>
        public virtual bool WaitOldest(out KOVL_HANDLE OverlappedK, int TimeoutMS, KOVL_WAIT_FLAG WaitFlags, out uint TransferredLength)
        {
            return AllKFunctions.OvlK_WaitOldest(mHandleStruct, out OverlappedK, TimeoutMS, WaitFlags, out TransferredLength);
        }

        /// <Summary>Waits for overlapped I/O completion, cancels on a timeout error.</Summary>
        public static bool WaitOrCancel(KOVL_HANDLE OverlappedK, int TimeoutMS, out uint TransferredLength)
        {
            return AllKFunctions.OvlK_WaitOrCancel(OverlappedK, TimeoutMS, out TransferredLength);
        }

        /// <Summary>
        ///     Waits for overlapped I/O completion, cancels on a timeout error and always releases the OvlK handle back to
        ///     its pool.
        /// </Summary>
        public static bool WaitAndRelease(KOVL_HANDLE OverlappedK, int TimeoutMS, out uint TransferredLength)
        {
            return AllKFunctions.OvlK_WaitAndRelease(OverlappedK, TimeoutMS, out TransferredLength);
        }

        /// <Summary>Checks for i/o completion; returns immediately. (polling)</Summary>
        public static bool IsComplete(KOVL_HANDLE OverlappedK)
        {
            return AllKFunctions.OvlK_IsComplete(OverlappedK);
        }

        /// <Summary>Initializes an overlappedK for re-use. The overlappedK is not return to its pool.</Summary>
        public static bool ReUse(KOVL_HANDLE OverlappedK)
        {
            return AllKFunctions.OvlK_ReUse(OverlappedK);
        }
    }

    public class StmK : IDisposable
    {
        protected bool mbDisposed;
        protected KSTM_HANDLE mHandleStruct;

        protected StmK()
        {
        }

        /// <Summary>Initializes a new uni-directional pipe stream.</Summary>
        public StmK(KUSB_HANDLE UsbHandle, byte PipeID, int MaxTransferSize, int MaxPendingTransfers, int MaxPendingIO, ref KSTM_CALLBACK Callbacks, KSTM_FLAG Flags)
        {
            bool success = AllKFunctions.StmK_Init(out mHandleStruct, UsbHandle, PipeID, MaxTransferSize, MaxPendingTransfers, MaxPendingIO, ref Callbacks, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KSTM_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~StmK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.StmK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KSTM_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Initializes a new uni-directional pipe stream.</Summary>
        protected bool Init(KUSB_HANDLE UsbHandle, byte PipeID, int MaxTransferSize, int MaxPendingTransfers, int MaxPendingIO, ref KSTM_CALLBACK Callbacks, KSTM_FLAG Flags)
        {
            bool success = AllKFunctions.StmK_Init(out mHandleStruct, UsbHandle, PipeID, MaxTransferSize, MaxPendingTransfers, MaxPendingIO, ref Callbacks, Flags);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Starts the internal stream thread.</Summary>
        public virtual bool Start()
        {
            return AllKFunctions.StmK_Start(mHandleStruct);
        }

        /// <Summary>Stops the internal stream thread.</Summary>
        public virtual bool Stop(int TimeoutCancelMS)
        {
            return AllKFunctions.StmK_Stop(mHandleStruct, TimeoutCancelMS);
        }

        /// <Summary>Reads data from the stream buffer.</Summary>
        public virtual bool Read(IntPtr Buffer, int Offset, int Length, out uint TransferredLength)
        {
            return AllKFunctions.StmK_Read(mHandleStruct, Buffer, Offset, Length, out TransferredLength);
        }

        /// <Summary>Reads data from the stream buffer.</Summary>
        public virtual bool Read(Array Buffer, int Offset, int Length, out uint TransferredLength)
        {
            return AllKFunctions.StmK_Read(mHandleStruct, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), Offset, Length, out TransferredLength);
        }

        /// <Summary>Writes data to the stream buffer.</Summary>
        public virtual bool Write(IntPtr Buffer, int Offset, int Length, out uint TransferredLength)
        {
            return AllKFunctions.StmK_Write(mHandleStruct, Buffer, Offset, Length, out TransferredLength);
        }

        /// <Summary>Writes data to the stream buffer.</Summary>
        public virtual bool Write(Array Buffer, int Offset, int Length, out uint TransferredLength)
        {
            return AllKFunctions.StmK_Write(mHandleStruct, Marshal.UnsafeAddrOfPinnedArrayElement(Buffer, 0), Offset, Length, out TransferredLength);
        }
    }

    public class IsoK : IDisposable
    {
        private static readonly int ofsFlags = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "Flags").ToInt32();
        private static readonly int ofsStartFrame = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "StartFrame").ToInt32();
        private static readonly int ofsErrorCount = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "ErrorCount").ToInt32();
        private static readonly int ofsNumberOfPackets = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "NumberOfPackets").ToInt32();
        private static readonly int ofsUrbHdrStatus = Marshal.OffsetOf(typeof(KISO_CONTEXT_MAP), "UrbHdrStatus").ToInt32();
        protected bool mbDisposed;
        protected KISO_CONTEXT mHandleStruct;

        protected IsoK()
        {
        }


        /// <Summary>Creates a new isochronous transfer context for libusbK only.</Summary>
        public IsoK(int NumberOfPackets, int StartFrame)
        {
            bool success = AllKFunctions.IsoK_Init(out mHandleStruct, NumberOfPackets, StartFrame);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KISO_CONTEXT Handle
        {
            get { return mHandleStruct; }
        }


        /// <Summary>Additional ISO transfer flags. See \ref KISO_FLAG.</Summary>
        public KISO_FLAG Flags
        {
            get { return (KISO_FLAG) Marshal.ReadInt32(mHandleStruct.Pointer, ofsFlags); }

            set { Marshal.WriteInt32(mHandleStruct.Pointer, ofsFlags, (int) value); }
        }


        /// <Summary>Specifies the frame number that the transfer should begin on (0 for ASAP).</Summary>

        public uint StartFrame
        {
            get { return (uint) Marshal.ReadInt32(mHandleStruct.Pointer, ofsStartFrame); }

            set { Marshal.WriteInt32(mHandleStruct.Pointer, ofsStartFrame, (int) value); }
        }


        /// <Summary>
        ///     Contains the number of packets that completed with an error condition on return from the host controller
        ///     driver.
        /// </Summary>

        public short ErrorCount
        {
            get { return Marshal.ReadInt16(mHandleStruct.Pointer, ofsErrorCount); }

            set { Marshal.WriteInt16(mHandleStruct.Pointer, ofsErrorCount, value); }
        }


        /// <Summary>Specifies the number of packets that are described by the variable-length array member \c IsoPacket.</Summary>

        public short NumberOfPackets
        {
            get { return Marshal.ReadInt16(mHandleStruct.Pointer, ofsNumberOfPackets); }

            set { Marshal.WriteInt16(mHandleStruct.Pointer, ofsNumberOfPackets, value); }
        }


        /// <Summary>Contains the URB Hdr.Status value on return from the host controller driver.</Summary>

        public uint UrbHdrStatus
        {
            get { return (uint) Marshal.ReadInt32(mHandleStruct.Pointer, ofsUrbHdrStatus); }

            set { Marshal.WriteInt32(mHandleStruct.Pointer, ofsUrbHdrStatus, (int) value); }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~IsoK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.IsoK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KISO_CONTEXT(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Creates a new isochronous transfer context for libusbK only.</Summary>
        protected bool Init(int NumberOfPackets, int StartFrame)
        {
            bool success = AllKFunctions.IsoK_Init(out mHandleStruct, NumberOfPackets, StartFrame);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Convenience function for setting the offset of all ISO packets of an isochronous transfer context.</Summary>
        public virtual bool SetPackets(int PacketSize)
        {
            return AllKFunctions.IsoK_SetPackets(mHandleStruct, PacketSize);
        }

        /// <Summary>Convenience function for setting all fields of a \ref KISO_PACKET.</Summary>
        public virtual bool SetPacket(int PacketIndex, ref KISO_PACKET IsoPacket)
        {
            return AllKFunctions.IsoK_SetPacket(mHandleStruct, PacketIndex, ref IsoPacket);
        }

        /// <Summary>Convenience function for getting all fields of a \ref KISO_PACKET.</Summary>
        public virtual bool GetPacket(int PacketIndex, out KISO_PACKET IsoPacket)
        {
            return AllKFunctions.IsoK_GetPacket(mHandleStruct, PacketIndex, out IsoPacket);
        }

        /// <Summary>Convenience function for enumerating ISO packets of an isochronous transfer context.</Summary>
        public virtual bool EnumPackets(KISO_ENUM_PACKETS_CB EnumPackets, int StartPacketIndex, IntPtr UserState)
        {
            return AllKFunctions.IsoK_EnumPackets(mHandleStruct, EnumPackets, StartPacketIndex, UserState);
        }

        /// <Summary>Convenience function for re-using an isochronous transfer context in a subsequent request.</Summary>
        public virtual bool ReUse()
        {
            return AllKFunctions.IsoK_ReUse(mHandleStruct);
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
        private struct KISO_CONTEXT_MAP
        {
            /// <Summary>Additional ISO transfer flags. See \ref KISO_FLAG.</Summary>
            private readonly KISO_FLAG Flags;

            /// <Summary>Specifies the frame number that the transfer should begin on (0 for ASAP).</Summary>
            private readonly uint StartFrame;

            /// <Summary>
            ///     Contains the number of packets that completed with an error condition on return from the host controller
            ///     driver.
            /// </Summary>
            private readonly short ErrorCount;

            /// <Summary>Specifies the number of packets that are described by the variable-length array member \c IsoPacket.</Summary>
            private readonly short NumberOfPackets;

            /// <Summary>Contains the URB Hdr.Status value on return from the host controller driver.</Summary>
            private readonly uint UrbHdrStatus;
        }
    }

    public class IsochK : IDisposable
    {
        protected bool mbDisposed;
        protected KISOCH_HANDLE mHandleStruct;

        protected IsochK()
        {
        }

        /// <Summary>Creates a new isochronous transfer handle for libusbK or WinUSB.</Summary>
        public IsochK(KUSB_HANDLE InterfaceHandle, byte PipeId, uint MaxNumberOfPackets, IntPtr TransferBuffer, uint TransferBufferSize)
        {
            bool success = AllKFunctions.IsochK_Init(out mHandleStruct, InterfaceHandle, PipeId, MaxNumberOfPackets, TransferBuffer, TransferBufferSize);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
        }

        /// <summary>Gets the handle class structure.</summary>
        public KISOCH_HANDLE Handle
        {
            get { return mHandleStruct; }
        }

        /// <summary>Explicitly closes and frees the handle.</summary>
        public virtual void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~IsochK()
        {
            Dispose(false);
        }

        /// <summary>Calls the dispose method.</summary>
        public virtual void Free()
        {
            Dispose();
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!mbDisposed)
            {
                if (mHandleStruct.Pointer != IntPtr.Zero)
                {
                    AllKFunctions.IsochK_Free(mHandleStruct);
                    Debug.Print("{0} Dispose: Freed Handle:{1:X16}h Explicit:{2}", GetType().Name, mHandleStruct.Pointer.ToInt64(), disposing);
                }

                else
                {
                    Debug.Print("{0} Dispose: [WARNING] Handle is null", GetType().Name);
                }

                mHandleStruct = new KISOCH_HANDLE(IntPtr.Zero);
                mbDisposed = true;
            }
        }

        /// <Summary>Creates a new isochronous transfer handle for libusbK or WinUSB.</Summary>
        protected bool Init(KUSB_HANDLE InterfaceHandle, byte PipeId, uint MaxNumberOfPackets, IntPtr TransferBuffer, uint TransferBufferSize)
        {
            bool success = AllKFunctions.IsochK_Init(out mHandleStruct, InterfaceHandle, PipeId, MaxNumberOfPackets, TransferBuffer, TransferBufferSize);

            if (!success) throw new Exception(string.Format("{0} failed initializing. ErrorCode={1:X8}h", GetType().Name, Marshal.GetLastWin32Error()));

            Debug.Print("{0} Init: handle 0x{1:X16}", GetType().Name, mHandleStruct.Pointer.ToInt64());
            return true;
        }

        /// <Summary>Convenience function for setting the offsets and lengths of all ISO packets of an isochronous transfer handle.</Summary>
        public virtual bool SetPacketOffsets(uint PacketSize)
        {
            return AllKFunctions.IsochK_SetPacketOffsets(mHandleStruct, PacketSize);
        }

        /// <Summary>Convenience function for setting all fields in an isochronous transfer packet.</Summary>
        public virtual bool SetPacket(uint PacketIndex, uint Offset, uint Length, uint Status)
        {
            return AllKFunctions.IsochK_SetPacket(mHandleStruct, PacketIndex, Offset, Length, Status);
        }

        /// <Summary>Convenience function for getting all fields in an isochronous transfer packet.</Summary>
        public virtual bool GetPacket(uint PacketIndex, out uint Offset, out uint Length, out uint Status)
        {
            return AllKFunctions.IsochK_GetPacket(mHandleStruct, PacketIndex, out Offset, out Length, out Status);
        }

        /// <Summary>Convenience function for enumerating ISO packets of an isochronous transfer context.</Summary>
        public virtual bool EnumPackets(KISOCH_ENUM_PACKETS_CB EnumPackets, uint StartPacketIndex, IntPtr UserState)
        {
            return AllKFunctions.IsochK_EnumPackets(mHandleStruct, EnumPackets, StartPacketIndex, UserState);
        }

        /// <Summary>Helper function for isochronous packet/transfer calculations.</Summary>
        public static bool CalcPacketInformation(bool IsHighSpeed, ref WINUSB_PIPE_INFORMATION_EX PipeInformationEx, out KISOCH_PACKET_INFORMATION PacketInformation)
        {
            return AllKFunctions.IsochK_CalcPacketInformation(IsHighSpeed, ref PipeInformationEx, out PacketInformation);
        }

        /// <Summary>Gets the number of iso packets that will be used.</Summary>
        public virtual bool GetNumberOfPackets(out uint NumberOfPackets)
        {
            return AllKFunctions.IsochK_GetNumberOfPackets(mHandleStruct, out NumberOfPackets);
        }

        /// <Summary>Sets the number of iso packets that will be used.</Summary>
        public virtual bool SetNumberOfPackets(uint NumberOfPackets)
        {
            return AllKFunctions.IsochK_SetNumberOfPackets(mHandleStruct, NumberOfPackets);
        }
    }
}