First version.

1 files changed, 1653 insertions, 0 deletions

diff --git a/nimbluez/msbt/ms_bluetoothapis.nim b/nimbluez/msbt/ms_bluetoothapis.nim
new file mode 100644
index 0000000..c895128
--- /dev/null
+++ b/nimbluez/msbt/ms_bluetoothapis.nim
@@ -0,0 +1,1653 @@
+#
+#  Copyright 2002 - 2004, Microsoft Corporation
+#
+#////////////////////////////////////////////////////////////////////////////
+
+{.deadCodeElim: on.}
+when not defined(windows):
+  {.error: "MSBT is supported by windows".}
+
+
+const
+  libbluetooth* = "bthprops.cpl"
+
+import winlean
+import ms_bthdef, ms_bthsdpdef
+
+const
+  BTH_MAX_PIN_SIZE = 16
+
+const
+  BLUETOOTH_MAX_NAME_SIZE* = (248)
+  BLUETOOTH_MAX_PASSKEY_SIZE* = (16)
+  BLUETOOTH_MAX_PASSKEY_BUFFER_SIZE* = (BLUETOOTH_MAX_PASSKEY_SIZE + 1)
+  BLUETOOTH_MAX_SERVICE_NAME_SIZE* = (256)
+  BLUETOOTH_DEVICE_NAME_SIZE* = (256)
+
+# ***************************************************************************
+#
+#  Bluetooth Address
+#
+# ***************************************************************************
+type
+  INNER_C_UNION_1866013399* = object  {.union.}
+    ullLong*: BTH_ADDR    #  easier to compare again BLUETOOTH_NULL_ADDRESS
+    rgBytes*: array[6, BYTE] #  easier to format when broken out
+  BLUETOOTH_ADDRESS_STRUCT* = object
+    ano_116103095*: INNER_C_UNION_1866013399
+  BLUETOOTH_ADDRESS* = BLUETOOTH_ADDRESS_STRUCT
+
+const
+  BLUETOOTH_NULL_ADDRESS* = 0x0'i64
+type
+  BLUETOOTH_LOCAL_SERVICE_INFO_STRUCT* = object
+    Enabled*: BOOL        #  If TRUE, the enable the services
+    btAddr*: BLUETOOTH_ADDRESS #  If service is to be advertised for a particular remote device
+    szName*: array[BLUETOOTH_MAX_SERVICE_NAME_SIZE, WCHAR] #  SDP Service Name to be advertised.
+    szDeviceString*: array[BLUETOOTH_DEVICE_NAME_SIZE, WCHAR] #  Local device name (if any) like COM4 or LPT1
+  BLUETOOTH_LOCAL_SERVICE_INFO* = BLUETOOTH_LOCAL_SERVICE_INFO_STRUCT
+  PBLUETOOTH_LOCAL_SERVICE_INFO* = ptr BLUETOOTH_LOCAL_SERVICE_INFO
+# ***************************************************************************
+#
+#  Radio Enumeration
+#
+#  Description:
+#      This group of APIs enumerates the installed Bluetooth radios.
+#
+#  Sample Usage:
+#      HANDLE hRadio;
+#      BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) };
+#
+#      HBLUETOOTH_RADIO_FIND hFind = BluetoothFindFirstRadio( &btfrp, &hRadio );
+#      if ( NULL != hFind )
+#      {
+#          do
+#          {
+#              //
+#              //  TODO: Do something with the radio handle.
+#              //
+#
+#              CloseHandle( hRadio );
+#
+#          } while( BluetoothFindNextRadio( hFind, &hRadio ) );
+#
+#          BluetoothFindRadioClose( hFind );
+#      }
+#
+# ***************************************************************************
+type
+  BLUETOOTH_FIND_RADIO_PARAMS* = object
+    dwSize*: DWORD        #  IN  sizeof this structure
+
+  HBLUETOOTH_RADIO_FIND* = HANDLE
+#
+#  Description:
+#      Begins the enumeration of local Bluetooth radios.
+#
+#  Parameters:
+#      pbtfrp
+#          A pointer to a BLUETOOTH_FIND_RADIO_PARAMS structure. The dwSize
+#          member of this structure must match the sizeof the of the structure.
+#
+#      phRadio
+#          A pointer where the first radio HANDLE enumerated will be returned.
+#
+#  Return Values:
+#      NULL
+#          Error opening radios or no devices found. Use GetLastError() for
+#          more info.
+#
+#          ERROR_INVALID_PARAMETER
+#              pbtfrp parameter is NULL.
+#
+#          ERROR_REVISION_MISMATCH
+#              The pbtfrp structure is not the right length.
+#
+#          ERROR_OUTOFMEMORY
+#              Out of memory.
+#
+#          other Win32 errors.
+#
+#      any other
+#          Success. The return handle is valid and phRadio points to a valid handle.
+#
+proc BluetoothFindFirstRadio*(pbtfrp: ptr BLUETOOTH_FIND_RADIO_PARAMS;
+                              phRadio: ptr HANDLE): HBLUETOOTH_RADIO_FIND {.
+    stdcall, importc: "BluetoothFindFirstRadio", dynlib: libbluetooth.}
+#
+#  Description:
+#      Finds the next installed Bluetooth radio.
+#
+#  Parameters:
+#      hFind
+#          The handle returned by BluetoothFindFirstRadio().
+#
+#      phRadio
+#          A pointer where the next radio HANDLE enumerated will be returned.
+#
+#  Return Values:
+#      TRUE
+#          Next device succesfully found. pHandleOut points to valid handle.
+#
+#      FALSE
+#          No device found. pHandleOut points to an invalid handle. Call
+#          GetLastError() for more details.
+#
+#          ERROR_INVALID_HANDLE
+#              The handle is NULL.
+#
+#          ERROR_NO_MORE_ITEMS
+#              No more radios found.
+#
+#          ERROR_OUTOFMEMORY
+#              Out of memory.
+#
+#          other Win32 errors
+#
+proc BluetoothFindNextRadio*(hFind: HBLUETOOTH_RADIO_FIND;
+                             phRadio: ptr HANDLE): BOOL {.stdcall,
+    importc: "BluetoothFindNextRadio", dynlib: libbluetooth.}
+#
+#  Description:
+#      Closes the enumeration handle.
+#
+#  Parameters
+#      hFind
+#          The handle returned by BluetoothFindFirstRadio().
+#
+#  Return Values:
+#      TRUE
+#          Handle succesfully closed.
+#
+#      FALSE
+#          Failure. Check GetLastError() for details.
+#
+#          ERROR_INVALID_HANDLE
+#              The handle is NULL.
+#
+proc BluetoothFindRadioClose*(hFind: HBLUETOOTH_RADIO_FIND): BOOL {.stdcall,
+    importc: "BluetoothFindRadioClose", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Radio Information
+#
+# ***************************************************************************
+type
+  BLUETOOTH_RADIO_INFO* = object
+    dwSize*: DWORD        # Size, in bytes, of this entire data structure
+    address*: BLUETOOTH_ADDRESS # Address of the local radio
+    szName*: array[BLUETOOTH_MAX_NAME_SIZE, WCHAR] # Name of the local radio
+    ulClassofDevice*: ULONG # Class of device for the local radio
+    lmpSubversion*: USHORT # lmpSubversion, manufacturer specifc.
+    manufacturer*: USHORT # Manufacturer of the radio, BTH_MFG_Xxx value.  For the most up to date
+                          # list, goto the Bluetooth specification website and get the Bluetooth
+                          # assigned numbers document.
+
+  PBLUETOOTH_RADIO_INFO* = ptr BLUETOOTH_RADIO_INFO
+#
+#  Description:
+#      Retrieves the information about the radio represented by the handle.
+#
+#  Parameters:
+#      hRadio
+#          Handle to a local radio retrieved through BluetoothFindFirstRadio()
+#          et al or SetupDiEnumerateDeviceInterfaces()
+#
+#      pRadioInfo
+#          Radio information to be filled in. The dwSize member must match the
+#          size of the structure.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The information was retrieved successfully.
+#
+#      ERROR_INVALID_PARAMETER
+#          pRadioInfo or hRadio is NULL.
+#
+#      ERROR_REVISION_MISMATCH
+#          pRadioInfo->dwSize is invalid.
+#
+#      other Win32 error codes.
+#
+proc BluetoothGetRadioInfo*(hRadio: HANDLE;
+                            pRadioInfo: PBLUETOOTH_RADIO_INFO): DWORD {.
+    stdcall, importc: "BluetoothGetRadioInfo", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Device Information Stuctures
+#
+# ***************************************************************************
+type
+  BLUETOOTH_DEVICE_INFO_STRUCT* = object
+    dwSize*: DWORD        #  size, in bytes, of this structure - must be the sizeof(BLUETOOTH_DEVICE_INFO)
+    Address*: BLUETOOTH_ADDRESS #  Bluetooth address
+    ulClassofDevice*: ULONG #  Bluetooth "Class of Device"
+    fConnected*: BOOL     #  Device connected/in use
+    fRemembered*: BOOL    #  Device remembered
+    fAuthenticated*: BOOL #  Device authenticated/paired/bonded
+    stLastSeen*: SYSTEMTIME #  Last time the device was seen
+    stLastUsed*: SYSTEMTIME #  Last time the device was used for other than RNR, inquiry, or SDP
+    szName*: array[BLUETOOTH_MAX_NAME_SIZE, WCHAR] #  Name of the device
+
+  BLUETOOTH_DEVICE_INFO* = BLUETOOTH_DEVICE_INFO_STRUCT
+  PBLUETOOTH_DEVICE_INFO* = ptr BLUETOOTH_DEVICE_INFO
+#
+# Support added after KB942567
+#
+type
+  INNER_C_UNION_2689769052* = object  {.union.}
+    Numeric_Value*: ULONG
+    Passkey*: ULONG
+
+type
+  BLUETOOTH_AUTHENTICATION_METHOD* {.size: sizeof(cint).} = enum
+    BLUETOOTH_AUTHENTICATION_METHOD_LEGACY = 0x00000001,
+    BLUETOOTH_AUTHENTICATION_METHOD_OOB,
+    BLUETOOTH_AUTHENTICATION_METHOD_NUMERIC_COMPARISON,
+    BLUETOOTH_AUTHENTICATION_METHOD_PASSKEY_NOTIFICATION,
+    BLUETOOTH_AUTHENTICATION_METHOD_PASSKEY
+  PBLUETOOTH_AUTHENTICATION_METHOD* = ptr BLUETOOTH_AUTHENTICATION_METHOD
+  BLUETOOTH_IO_CAPABILITY* {.size: sizeof(cint).} = enum
+    BLUETOOTH_IO_CAPABILITY_DISPLAYONLY = 0x00000000,
+    BLUETOOTH_IO_CAPABILITY_DISPLAYYESNO = 0x00000001,
+    BLUETOOTH_IO_CAPABILITY_KEYBOARDONLY = 0x00000002,
+    BLUETOOTH_IO_CAPABILITY_NOINPUTNOOUTPUT = 0x00000003,
+    BLUETOOTH_IO_CAPABILITY_UNDEFINED = 0x000000FF
+  BLUETOOTH_AUTHENTICATION_REQUIREMENTS* {.size: sizeof(cint).} = enum
+    BLUETOOTH_MITM_ProtectionNotRequired = 0,
+    BLUETOOTH_MITM_ProtectionRequired = 0x00000001,
+    BLUETOOTH_MITM_ProtectionNotRequiredBonding = 0x00000002,
+    BLUETOOTH_MITM_ProtectionRequiredBonding = 0x00000003,
+    BLUETOOTH_MITM_ProtectionNotRequiredGeneralBonding = 0x00000004,
+    BLUETOOTH_MITM_ProtectionRequiredGeneralBonding = 0x00000005,
+    BLUETOOTH_MITM_ProtectionNotDefined = 0x000000FF
+  BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS* = object
+    deviceInfo*: BLUETOOTH_DEVICE_INFO
+    authenticationMethod*: BLUETOOTH_AUTHENTICATION_METHOD
+    ioCapability*: BLUETOOTH_IO_CAPABILITY
+    authenticationRequirements*: BLUETOOTH_AUTHENTICATION_REQUIREMENTS
+    ano_869376366*: INNER_C_UNION_2689769052
+
+  PBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS* = ptr BLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS
+# ***************************************************************************
+#
+#  Device Enumeration
+#
+#  Description:
+#      Enumerates the Bluetooth devices. The types of returned device depends
+#      on the flags set in the BLUETOOTH_DEVICE_SEARCH_PARAMS (see structure
+#      definition for details).
+#
+#  Sample Usage:
+#      HBLUETOOTH_DEVICE_FIND hFind;
+#      BLUETOOTH_DEVICE_SEARCH_PARAMS btsp = { sizeof(btsp) };
+#      BLUETOOTH_DEVICE_INFO btdi = { sizeof(btdi) };
+#
+#      btsp.fReturnAuthenticated = TRUE;
+#      btsp.fReturnRemembered    = TRUE;
+#
+#      hFind = BluetoothFindFirstDevice( &btsp, &btdi );
+#      if ( NULL != hFind )
+#      {
+#          do
+#          {
+#              //
+#              //  TODO:   Do something useful with the device info.
+#              //
+#
+#          } while( BluetoothFindNextDevice( hFind, &btdi ) );
+#
+#          BluetoothFindDeviceClose( hFind );
+#      }
+#
+# ***************************************************************************
+type
+  BLUETOOTH_DEVICE_SEARCH_PARAMS* = object
+    dwSize*: DWORD        #  IN  sizeof this structure
+    fReturnAuthenticated*: BOOL #  IN  return authenticated devices
+    fReturnRemembered*: BOOL #  IN  return remembered devices
+    fReturnUnknown*: BOOL #  IN  return unknown devices
+    fReturnConnected*: BOOL #  IN  return connected devices
+    fIssueInquiry*: BOOL  #  IN  issue a new inquiry
+    cTimeoutMultiplier*: UCHAR #  IN  timeout for the inquiry
+    hRadio*: HANDLE       #  IN  handle to radio to enumerate - NULL == all radios will be searched
+
+  HBLUETOOTH_DEVICE_FIND* = HANDLE
+#
+#  Description:
+#      Begins the enumeration of Bluetooth devices.
+#
+#  Parameters:
+#      pbtsp
+#          A pointer to a BLUETOOTH_DEVICE_SEARCH_PARAMS structure. This
+#          structure contains the flags and inputs used to conduct the search.
+#          See BLUETOOTH_DEVICE_SEARCH_PARAMS for details.
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure to return information
+#          about the first Bluetooth device found. Note that the dwSize member
+#          of the structure must be the sizeof(BLUETOOTH_DEVICE_INFO) before
+#          calling because the APIs hast to know the size of the buffer being
+#          past in. The dwSize member must also match the exact
+#          sizeof(BLUETOOTH_DEVICE_INFO) or the call will fail.
+#
+#  Return Values:
+#      NULL
+#          Error opening radios or not devices found. Use GetLastError for more info.
+#
+#          ERROR_INVALID_PARAMETER
+#              pbtsp parameter or pbtdi parameter is NULL.
+#
+#          ERROR_REVISION_MISMATCH
+#              The pbtfrp structure is not the right length.
+#
+#          other Win32 errors
+#
+#      any other value
+#          Success. The return handle is valid and pbtdi points to valid data.
+#
+proc BluetoothFindFirstDevice*(pbtsp: ptr BLUETOOTH_DEVICE_SEARCH_PARAMS;
+                               pbtdi: ptr BLUETOOTH_DEVICE_INFO): HBLUETOOTH_DEVICE_FIND {.
+    stdcall, importc: "BluetoothFindFirstDevice", dynlib: libbluetooth.}
+#
+#  Description:
+#      Finds the next Bluetooth device in the enumeration.
+#
+#  Parameters:
+#      hFind
+#          The handle returned from BluetoothFindFirstDevice().
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure to return information
+#          about the first Bluetooth device found. Note that the dwSize member
+#          of the structure must be the sizeof(BLUETOOTH_DEVICE_INFO) before
+#          calling because the APIs hast to know the size of the buffer being
+#          past in. The dwSize member must also match the exact
+#          sizeof(BLUETOOTH_DEVICE_INFO) or the call will fail.
+#
+#  Return Values:
+#      TRUE
+#          Next device succesfully found. pHandleOut points to valid handle.
+#
+#      FALSE
+#          No device found. pHandleOut points to an invalid handle. Call
+#          GetLastError() for more details.
+#
+#          ERROR_INVALID_HANDLE
+#              The handle is NULL.
+#
+#          ERROR_NO_MORE_ITEMS
+#              No more radios found.
+#
+#          ERROR_OUTOFMEMORY
+#              Out of memory.
+#
+#          other Win32 errors
+#
+proc BluetoothFindNextDevice*(hFind: HBLUETOOTH_DEVICE_FIND;
+                              pbtdi: ptr BLUETOOTH_DEVICE_INFO): BOOL {.
+    stdcall, importc: "BluetoothFindNextDevice", dynlib: libbluetooth.}
+#
+#  Description:
+#      Closes the enumeration handle.
+#
+#  Parameters:
+#      hFind
+#          The handle returned from BluetoothFindFirstDevice().
+#
+#  Return Values:
+#      TRUE
+#          Handle succesfully closed.
+#
+#      FALSE
+#          Failure. Check GetLastError() for details.
+#
+#          ERROR_INVALID_HANDLE
+#              The handle is NULL.
+#
+proc BluetoothFindDeviceClose*(hFind: HBLUETOOTH_DEVICE_FIND): BOOL {.
+    stdcall, importc: "BluetoothFindDeviceClose", dynlib: libbluetooth.}
+#
+#  Description:
+#      Retrieves information about a remote device.
+#
+#      Fill in the dwSize and the Address members of the pbtdi structure
+#      being passed in. On success, the rest of the members will be filled
+#      out with the information that the system knows.
+#
+#  Parameters:
+#      hRadio
+#          Handle to a local radio retrieved through BluetoothFindFirstRadio()
+#          et al or SetupDiEnumerateDeviceInterfaces()
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure to return information
+#          about the first Bluetooth device found. The dwSize member of the
+#          structure must be the sizeof the structure in bytes. The Address
+#          member must be filled out with the Bluetooth address of the remote
+#          device.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          Success. Information returned.
+#
+#      ERROR_REVISION_MISMATCH
+#          The size of the BLUETOOTH_DEVICE_INFO isn't compatible. Check
+#          the dwSize member of the BLUETOOTH_DEVICE_INFO structure you
+#          passed in.
+#
+#      ERROR_NOT_FOUND
+#          The radio is not known by the system or the Address field of
+#          the BLUETOOTH_DEVICE_INFO structure is all zeros.
+#
+#      ERROR_INVALID_PARAMETER
+#          pbtdi is NULL.
+#
+#      other error codes
+#
+proc BluetoothGetDeviceInfo*(hRadio: HANDLE;
+                             pbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {.
+    stdcall, importc: "BluetoothGetDeviceInfo", dynlib: libbluetooth.}
+#
+#  Description:
+#      Updates the computer local cache about the device.
+#
+#  Parameters:
+#      pbtdi
+#          A pointer to the BLUETOOTH_DEVICE_INFO structure to be updated.
+#          The following members must be valid:
+#              dwSize
+#                  Must match the size of the structure.
+#              Address
+#                  Must be a previously found radio address.
+#              szName
+#                  New name to be stored.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The device information was updated successfully.
+#
+#      ERROR_INVALID_PARAMETER
+#          pbtdi is NULL.
+#
+#      ERROR_REVISION_MISMATCH
+#          pbtdi->dwSize is invalid.
+#
+#      other Win32 error codes.
+#
+proc BluetoothUpdateDeviceRecord*(pbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {.
+    stdcall, importc: "BluetoothUpdateDeviceRecord", dynlib: libbluetooth.}
+#
+#  Description:
+#      Delete the authentication (aka "bond") between the computer and the
+#      device. Also purges any cached information about the device.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The device was removed successfully.
+#
+#      ERROR_NOT_FOUND
+#          The device was not found. If no Bluetooth radio is installed,
+#          the devices could not be enumerated or removed.
+#
+proc BluetoothRemoveDevice*(pAddress: ptr BLUETOOTH_ADDRESS): DWORD {.
+    stdcall, importc: "BluetoothRemoveDevice", dynlib: libbluetooth.}
+when not (hostCPU == "arm"):
+  #
+  # ***************************************************************************
+  #
+  #  Device Picker Dialog
+  #
+  #  Description:
+  #      Invokes a common dialog for selecting Bluetooth devices. The list
+  #      of devices displayed to the user is determined by the flags and
+  #      settings the caller specifies in the BLUETOOTH_SELECT_DEVICE_PARAMS
+  #      (see structure definition for more details).
+  #
+  #      If BluetoothSelectDevices() returns TRUE, the caller must call
+  #      BluetoothSelectDevicesFree() or memory will be leaked within the
+  #      process.
+  #
+  #  Sample Usage:
+  #
+  #      BLUETOOTH_SELECT_DEVICE_PARAMS btsdp = { sizeof(btsdp) };
+  #
+  #      btsdp.hwndParent = hDlg;
+  #      btsdp.fShowUnknown = TRUE;
+  #      btsdp.fAddNewDeviceWizard = TRUE;
+  #
+  #      BOOL b = BluetoothSelectDevices( &btsdp );
+  #      if ( b )
+  #      {
+  #          BLUETOOTH_DEVICE_INFO * pbtdi = btsdp.pDevices;
+  #          for ( ULONG cDevice = 0; cDevice < btsdp.cNumDevices; cDevice ++ )
+  #          {
+  #              if ( pbtdi->fAuthenticated || pbtdi->fRemembered )
+  #              {
+  #                  //
+  #                  //  TODO:   Do something usefull with the device info
+  #                  //
+  #              }
+  #
+  #              pbtdi = (BLUETOOTH_DEVICE_INFO *) ((LPBYTE)pbtdi + pbtdi->dwSize);
+  #          }
+  #
+  #          BluetoothSelectDevicesFree( &btsdp );
+  #      }
+  #
+  #
+  # ***************************************************************************
+  type
+    BLUETOOTH_COD_PAIRS* = object
+      ulCODMask*: ULONG   #  ClassOfDevice mask to compare
+      pcszDescription*: LPCWSTR #  Descriptive string of mask
+
+    PFN_DEVICE_CALLBACK* = proc (pvParam: LPVOID;
+                                 pDevice: ptr BLUETOOTH_DEVICE_INFO): BOOL {.
+        stdcall.}
+    BLUETOOTH_SELECT_DEVICE_PARAMS* = object
+      dwSize*: DWORD      #  IN  sizeof this structure
+      cNumOfClasses*: ULONG #  IN  Number in prgClassOfDevice - if ZERO search for all devices
+      prgClassOfDevices*: ptr BLUETOOTH_COD_PAIRS #  IN  Array of CODs to find.
+      pszInfo*: LPWSTR    #  IN  If not NULL, sets the "information" text
+      hwndParent*: HWND   #  IN  parent window - NULL == no parent
+      fForceAuthentication*: BOOL #  IN  If TRUE, authenication will be forced before returning
+      fShowAuthenticated*: BOOL #  IN  If TRUE, authenticated devices will be shown in the picker
+      fShowRemembered*: BOOL #  IN  If TRUE, remembered devices will be shown in the picker
+      fShowUnknown*: BOOL #  IN  If TRUE, unknown devices that are not authenticated or "remember" will be shown.
+      fAddNewDeviceWizard*: BOOL #  IN  If TRUE, invokes the add new device wizard.
+      fSkipServicesPage*: BOOL #  IN  If TRUE, skips the "Services" page in the wizard.
+      pfnDeviceCallback*: PFN_DEVICE_CALLBACK #  IN  If non-NULL, a callback that will be called for each device. If the
+                                              #      the callback returns TRUE, the item will be added. If the callback is
+                                              #      is FALSE, the item will not be shown.
+      pvParam*: LPVOID    #  IN  Parameter to be passed to pfnDeviceCallback as the pvParam.
+      cNumDevices*: DWORD #  IN  number calles wants - ZERO == no limit.
+                          #  OUT the number of devices returned.
+      pDevices*: PBLUETOOTH_DEVICE_INFO #  OUT pointer to an array for BLUETOOTH_DEVICE_INFOs.
+                                        #      call BluetoothSelectDevicesFree() to free
+
+  #
+  #  Description:
+  #      (See header above)
+  #
+  #  Return Values:
+  #      TRUE
+  #          User selected a device. pbtsdp->pDevices points to valid data.
+  #          Caller should check the fAuthenticated && fRemembered flags to
+  #          determine which devices we successfuly authenticated or valid
+  #          selections by the user.
+  #
+  #          Use BluetoothSelectDevicesFree() to free the nessecary data
+  #          such as pDevices only if this function returns TRUE.
+  #
+  #      FALSE
+  #          No valid data returned. Call GetLastError() for possible details
+  #          of the failure. If GLE() is:
+  #
+  #          ERROR_CANCELLED
+  #              The user cancelled  the request.
+  #
+  #          ERROR_INVALID_PARAMETER
+  #              The pbtsdp is NULL.
+  #
+  #          ERROR_REVISION_MISMATCH
+  #              The structure passed in as pbtsdp is of an unknown size.
+  #
+  #          other WIN32 errors
+  #
+  proc BluetoothSelectDevices*(pbtsdp: ptr BLUETOOTH_SELECT_DEVICE_PARAMS): BOOL {.
+      stdcall, importc: "BluetoothSelectDevices", dynlib: libbluetooth.}
+  #
+  #  Description:
+  #      This function should only be called if BluetoothSelectDevices() returns
+  #      TRUE. This function will free any memory and resource returned by the
+  #      BluetoothSelectDevices() in the BLUETOOTH_SELECT_DEVICE_PARAMS
+  #      structure.
+  #
+  #  Return Values:
+  #      TRUE
+  #          Success.
+  #
+  #      FALSE
+  #          Nothing to free.
+  #
+  proc BluetoothSelectDevicesFree*(pbtsdp: ptr BLUETOOTH_SELECT_DEVICE_PARAMS): BOOL {.
+      stdcall, importc: "BluetoothSelectDevicesFree", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Device Property Sheet
+#
+# ***************************************************************************
+#
+#  Description:
+#      Invokes the CPLs device info property sheet.
+#
+#  Parameters:
+#      hwndParent
+#          HWND to parent the property sheet.
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure of the device
+#          to be displayed.
+#
+#  Return Values:
+#      TRUE
+#          The property page was successfully displayed.
+#
+#      FALSE
+#          Failure. The property page was not displayed. Check GetLastError
+#          for more details.
+#
+proc BluetoothDisplayDeviceProperties*(hwndParent: HWND;
+    pbtdi: ptr BLUETOOTH_DEVICE_INFO): BOOL {.stdcall,
+    importc: "BluetoothDisplayDeviceProperties", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Radio Authentication
+#
+# ***************************************************************************
+#
+#  Description:
+#      Sends an authentication request to a remote device.
+#
+#      There are two modes of operation. "Wizard mode" and "Blind mode."
+#
+#      "Wizard mode" is invoked when the pszPasskey is NULL. This will cause
+#      the "Bluetooth Connection Wizard" to be invoked. The user will be
+#      prompted to enter a passkey during the wizard after which the
+#      authentication request will be sent. The user will see the success
+#      or failure of the authentication attempt. The user will also be
+#      given the oppurtunity to try to fix a failed authentication.
+#
+#      "Blind mode" is invoked when the pszPasskey is non-NULL. This will
+#      cause the computer to send a authentication request to the remote
+#      device. No UI is ever displayed. The Bluetooth status code will be
+#      mapped to a Win32 Error code.
+#
+#  Parameters:
+#
+#      hwndParent
+#          The window to parent the authentication wizard. If NULL, the
+#          wizard will be parented off the desktop.
+#
+#      hRadio
+#          A valid local radio handle or NULL. If NULL, then all radios will
+#          be tired. If any of the radios succeed, then the call will
+#          succeed.
+#
+#      pbtdi
+#          BLUETOOTH_DEVICE_INFO record of the device to be authenticated.
+#
+#      pszPasskey
+#          PIN to be used to authenticate the device.  If NULL, then UI is
+#          displayed and the user steps through the authentication process.
+#          If not NULL, no UI is shown.  The passkey is NOT NULL terminated.
+#
+#      ulPasskeyLength
+#          Length of szPassKey in bytes. The length must be less than or
+#          equal to BLUETOOTH_MAX_PASSKEY_SIZE * sizeof(WCHAR).
+#
+#  Return Values:
+#
+#      ERROR_SUCCESS
+#          Success.
+#
+#      ERROR_CANCELLED
+#          User aborted the operation.
+#
+#      ERROR_INVALID_PARAMETER
+#          The device structure in pbtdi is invalid.
+#
+#      ERROR_NO_MORE_ITEMS
+#          The device in pbtdi is already been marked as authenticated.
+#
+#      other WIN32 error
+#          Failure. Return value is the error code.
+#
+#      For "Blind mode," here is the current mapping of Bluetooth status
+#      code to Win32 error codes:
+#
+#          { BTH_ERROR_SUCCESS,                ERROR_SUCCESS },
+#          { BTH_ERROR_NO_CONNECTION,          ERROR_DEVICE_NOT_CONNECTED },
+#          { BTH_ERROR_PAGE_TIMEOUT,           WAIT_TIMEOUT },
+#          { BTH_ERROR_HARDWARE_FAILURE,       ERROR_GEN_FAILURE },
+#          { BTH_ERROR_AUTHENTICATION_FAILURE, ERROR_NOT_AUTHENTICATED },
+#          { BTH_ERROR_MEMORY_FULL,            ERROR_NOT_ENOUGH_MEMORY },
+#          { BTH_ERROR_CONNECTION_TIMEOUT,     WAIT_TIMEOUT },
+#          { BTH_ERROR_LMP_RESPONSE_TIMEOUT,   WAIT_TIMEOUT },
+#          { BTH_ERROR_MAX_NUMBER_OF_CONNECTIONS, ERROR_REQ_NOT_ACCEP },
+#          { BTH_ERROR_PAIRING_NOT_ALLOWED,    ERROR_ACCESS_DENIED },
+#          { BTH_ERROR_UNSPECIFIED_ERROR,      ERROR_NOT_READY },
+#          { BTH_ERROR_LOCAL_HOST_TERMINATED_CONNECTION, ERROR_VC_DISCONNECTED },
+#
+proc BluetoothAuthenticateDevice*(hwndParent: HWND; hRadio: HANDLE;
+                                  pbtbi: ptr BLUETOOTH_DEVICE_INFO;
+                                  pszPasskey: PWSTR; ulPasskeyLength: ULONG): DWORD {.
+    stdcall, importc: "BluetoothAuthenticateDevice", dynlib: libbluetooth,
+    deprecated.}
+#
+# Support added after KB942567
+#
+#
+# Replaces previous API
+#
+#
+# Common header for all PIN related structures
+#
+type
+  BLUETOOTH_PIN_INFO* = object
+    pin*: array[BTH_MAX_PIN_SIZE, UCHAR]
+    pinLength*: UCHAR
+
+  PBLUETOOTH_PIN_INFO* = ptr BLUETOOTH_PIN_INFO
+  BLUETOOTH_OOB_DATA_INFO* = object
+    C*: array[16, UCHAR]
+    R*: array[16, UCHAR]
+
+  PBLUETOOTH_OOB_DATA_INFO* = ptr BLUETOOTH_OOB_DATA_INFO
+  BLUETOOTH_NUMERIC_COMPARISON_INFO* = object
+    NumericValue*: ULONG
+
+  PBLUETOOTH_NUMERIC_COMPARISON_INFO* = ptr BLUETOOTH_NUMERIC_COMPARISON_INFO
+  BLUETOOTH_PASSKEY_INFO* = object
+    passkey*: ULONG
+
+  PBLUETOOTH_PASSKEY_INFO* = ptr BLUETOOTH_PASSKEY_INFO
+#
+#  Description:
+#      Sends an authentication request to a remote device.
+#
+#      There are two modes of operation. "Wizard mode" and "Blind mode."
+#
+#      "Wizard mode" is invoked when the pbtOobData is NULL. This will cause
+#      the "Bluetooth Connection Wizard" to be invoked. The user will be
+#      prompted to respond to the device authentication during the wizard
+#      after which the authentication request will be sent. The user will see the success
+#      or failure of the authentication attempt. The user will also be
+#      given the oppurtunity to try to fix a failed authentication.
+#
+#      "Blind mode" is invoked when the pbtOobData is non-NULL. This will
+#      cause the computer to send a authentication request to the remote
+#      device. No UI is ever displayed. The Bluetooth status code will be
+#      mapped to a Win32 Error code.
+#
+#  Parameters:
+#
+#      hwndParent
+#          The window to parent the authentication wizard. If NULL, the
+#          wizard will be parented off the desktop.
+#
+#      hRadio
+#          A valid local radio handle or NULL. If NULL, then all radios will
+#          be tired. If any of the radios succeed, then the call will
+#          succeed.
+#
+#      pbtdi
+#          BLUETOOTH_DEVICE_INFO record of the device to be authenticated.
+#
+#      pbtOobData
+#          Out of band data to be used to authenticate the device.  If NULL, then UI is
+#          displayed and the user steps through the authentication process.
+#          If not NULL, no UI is shown.
+#
+#      authenticationRequirement
+#          The Authentication Requirement of the caller.  MITMProtection*
+#
+#
+#  Return Values:
+#
+#      ERROR_SUCCESS
+#          Success.
+#
+#      ERROR_CANCELLED
+#          User aborted the operation.
+#
+#      ERROR_INVALID_PARAMETER
+#          The device structure in pbtdi is invalid.
+#
+#      ERROR_NO_MORE_ITEMS
+#          The device in pbtdi is already been marked as authenticated.
+#
+#      other WIN32 error
+#          Failure. Return value is the error code.
+#
+#      For "Blind mode," here is the current mapping of Bluetooth status
+#      code to Win32 error codes:
+#
+#          { BTH_ERROR_SUCCESS,                ERROR_SUCCESS },
+#          { BTH_ERROR_NO_CONNECTION,          ERROR_DEVICE_NOT_CONNECTED },
+#          { BTH_ERROR_PAGE_TIMEOUT,           WAIT_TIMEOUT },
+#          { BTH_ERROR_HARDWARE_FAILURE,       ERROR_GEN_FAILURE },
+#          { BTH_ERROR_AUTHENTICATION_FAILURE, ERROR_NOT_AUTHENTICATED },
+#          { BTH_ERROR_MEMORY_FULL,            ERROR_NOT_ENOUGH_MEMORY },
+#          { BTH_ERROR_CONNECTION_TIMEOUT,     WAIT_TIMEOUT },
+#          { BTH_ERROR_LMP_RESPONSE_TIMEOUT,   WAIT_TIMEOUT },
+#          { BTH_ERROR_MAX_NUMBER_OF_CONNECTIONS, ERROR_REQ_NOT_ACCEP },
+#          { BTH_ERROR_PAIRING_NOT_ALLOWED,    ERROR_ACCESS_DENIED },
+#          { BTH_ERROR_UNSPECIFIED_ERROR,      ERROR_NOT_READY },
+#          { BTH_ERROR_LOCAL_HOST_TERMINATED_CONNECTION, ERROR_VC_DISCONNECTED },
+#
+proc BluetoothAuthenticateDeviceEx*(hwndParentIn: HWND; hRadioIn: HANDLE;
+    pbtdiInout: ptr BLUETOOTH_DEVICE_INFO;
+    pbtOobData: PBLUETOOTH_OOB_DATA_INFO;
+    authenticationRequirement: BLUETOOTH_AUTHENTICATION_REQUIREMENTS): DWORD {.
+    stdcall, importc: "BluetoothAuthenticateDeviceEx",
+    dynlib: libbluetooth.}
+#
+#  Description:
+#      Allows the caller to prompt for multiple devices to be authenticated
+#      within a single instance of the "Bluetooth Connection Wizard."
+#
+#  Parameters:
+#
+#      hwndParent
+#          The window to parent the authentication wizard. If NULL, the
+#          wizard will be parented off the desktop.
+#
+#      hRadio
+#          A valid local radio handle or NULL. If NULL, then all radios will
+#          be tired. If any of the radios succeed, then the call will
+#          succeed.
+#
+#      cDevices
+#          Number of devices in the rgbtdi array.
+#
+#      rgbtdi
+#          An array BLUETOOTH_DEVICE_INFO records of the devices to be
+#          authenticated.
+#
+#  Return Values:
+#
+#      ERROR_SUCCESS
+#          Success. Check the fAuthenticate flag on each of the devices.
+#
+#      ERROR_CANCELLED
+#          User aborted the operation. Check the fAuthenticate flags on
+#          each device to determine if any of the devices were authenticated
+#          before the user cancelled the operation.
+#
+#      ERROR_INVALID_PARAMETER
+#          One of the items in the array of devices is invalid.
+#
+#      ERROR_NO_MORE_ITEMS
+#          All the devices in the array of devices are already been marked as
+#          being authenticated.
+#
+#      other WIN32 error
+#          Failure. Return value is the error code.
+#
+proc BluetoothAuthenticateMultipleDevices*(hwndParent: HWND; hRadio: HANDLE;
+    cDevices: DWORD; rgbtdi: ptr BLUETOOTH_DEVICE_INFO): DWORD {.stdcall,
+    importc: "BluetoothAuthenticateMultipleDevices", dynlib: libbluetooth,
+    deprecated.}
+#
+# Deprecated after Vista SP1 and KB942567
+#
+
+# ***************************************************************************
+#
+#  Bluetooth Services
+#
+# ***************************************************************************
+const
+  BLUETOOTH_SERVICE_DISABLE* = 0x00000000
+  BLUETOOTH_SERVICE_ENABLE* = 0x00000001
+  BLUETOOTH_SERVICE_MASK* = (
+    BLUETOOTH_SERVICE_DISABLE or BLUETOOTH_SERVICE_ENABLE)
+#
+#  Description:
+#      Enables/disables the services for a particular device.
+#
+#      The system maintains a mapping of service guids to supported drivers for
+#      Bluetooth-enabled devices. Enabling a service installs the corresponding
+#      device driver. Disabling a service removes the corresponding device driver.
+#
+#      If a non-supported service is enabled, a driver will not be installed.
+#
+#  Parameters
+#      hRadio
+#          Handle of the local Bluetooth radio device.
+#
+#      pbtdi
+#          Pointer to a BLUETOOTH_DEVICE_INFO record.
+#
+#      pGuidService
+#          The service GUID on the remote device.
+#
+#      dwServiceFlags
+#          Flags to adjust the service.
+#              BLUETOOTH_SERVICE_DISABLE   -   disable the service
+#              BLUETOOTH_SERVICE_ENABLE    -   enables the service
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The call was successful.
+#
+#      ERROR_INVALID_PARAMETER
+#          dwServiceFlags are invalid.
+#
+#      ERROR_SERVICE_DOES_NOT_EXIST
+#          The GUID in pGuidService is not supported.
+#
+#      other WIN32 error
+#          The call failed.
+#
+proc BluetoothSetServiceState*(hRadio: HANDLE;
+                               pbtdi: ptr BLUETOOTH_DEVICE_INFO;
+                               pGuidService: ptr GUID; dwServiceFlags: DWORD): DWORD {.
+    stdcall, importc: "BluetoothSetServiceState", dynlib: libbluetooth.}
+#
+#  Description:
+#      Enumerates the services guids enabled on a particular device. If hRadio
+#      is NULL, all device will be searched for the device and all the services
+#      enabled will be returned.
+#
+#  Parameters:
+#      hRadio
+#          Handle of the local Bluetooth radio device. If NULL, it will search
+#          all the radios for the address in the pbtdi.
+#
+#      pbtdi
+#          Pointer to a BLUETOOTH_DEVICE_INFO record.
+#
+#      pcService
+#          On input, the number of records pointed to by pGuidServices.
+#          On output, the number of valid records return in pGuidServices.
+#
+#      pGuidServices
+#          Pointer to memory that is at least *pcService in length.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The call succeeded. pGuidServices is valid.
+#
+#      ERROR_MORE_DATA
+#          The call succeeded. pGuidService contains an incomplete list of
+#          enabled service GUIDs.
+#
+#      other WIN32 errors
+#          The call failed.
+#
+proc BluetoothEnumerateInstalledServices*(hRadio: HANDLE;
+    pbtdi: ptr BLUETOOTH_DEVICE_INFO; pcServiceInout: ptr DWORD;
+    pGuidServices: ptr GUID): DWORD {.stdcall,
+    importc: "BluetoothEnumerateInstalledServices", dynlib: libbluetooth.}
+#
+#  Description:
+#      Change the discovery state of the local radio(s).
+#      If hRadio is NULL, all the radios will be set.
+#
+#      Use BluetoothIsDiscoverable() to determine the radios current state.
+#
+#      The system ensures that a discoverable system is connectable, thus
+#      the radio must allow incoming connections (see
+#      BluetoothEnableIncomingConnections) prior to making a radio
+#      discoverable. Failure to do so will result in this call failing
+#      (returns FALSE).
+#
+#  Parameters:
+#      hRadio
+#          If not NULL, changes the state of a specific radio.
+#          If NULL, the API will interate through all the radios.
+#
+#      fEnabled
+#          If FALSE, discovery will be disabled.
+#
+#  Return Values
+#      TRUE
+#          State was successfully changed. If the caller specified NULL for
+#          hRadio, at least of the radios accepted the state change.
+#
+#      FALSE
+#          State was not changed. If the caller specified NULL for hRadio, all
+#          of the radios did not accept the state change.
+#
+proc BluetoothEnableDiscovery*(hRadio: HANDLE; fEnabled: BOOL): BOOL {.
+    stdcall, importc: "BluetoothEnableDiscovery", dynlib: libbluetooth.}
+#
+#  Description:
+#      Determines if the Bluetooth radios are discoverable. If there are
+#      multiple radios, the first one to say it is discoverable will cause
+#      this function to return TRUE.
+#
+#  Parameters:
+#      hRadio
+#          Handle of the radio to check. If NULL, it will check all local
+#          radios.
+#
+#  Return Values:
+#      TRUE
+#          A least one radio is discoverable.
+#
+#      FALSE
+#          No radios are discoverable.
+#
+proc BluetoothIsDiscoverable*(hRadio: HANDLE): BOOL {.stdcall,
+    importc: "BluetoothIsDiscoverable", dynlib: libbluetooth.}
+#
+#  Description:
+#      Enables/disables the state of a radio to accept incoming connections.
+#      If hRadio is NULL, all the radios will be set.
+#
+#      Use BluetoothIsConnectable() to determine the radios current state.
+#
+#      The system enforces that a radio that is not connectable is not
+#      discoverable too. The radio must be made non-discoverable (see
+#      BluetoothEnableDiscovery) prior to making a radio non-connectionable.
+#      Failure to do so will result in this call failing (returns FALSE).
+#
+#  Parameters:
+#      hRadio
+#          If not NULL, changes the state of a specific radio.
+#          If NULL, the API will interate through all the radios.
+#
+#      fEnabled
+#          If FALSE, incoming connection will be disabled.
+#
+#  Return Values
+#      TRUE
+#          State was successfully changed. If the caller specified NULL for
+#          hRadio, at least of the radios accepted the state change.
+#
+#      FALSE
+#          State was not changed. If the caller specified NULL for hRadio, all
+#          of the radios did not accept the state change.
+#
+proc BluetoothEnableIncomingConnections*(hRadio: HANDLE; fEnabled: BOOL): BOOL {.
+    stdcall, importc: "BluetoothEnableIncomingConnections",
+    dynlib: libbluetooth.}
+#
+#  Description:
+#      Determines if the Bluetooth radios are connectable. If there are
+#      multiple radios, the first one to say it is connectable will cause
+#      this function to return TRUE.
+#
+#  Parameters:
+#      hRadio
+#          Handle of the radio to check. If NULL, it will check all local
+#          radios.
+#
+#  Return Values:
+#      TRUE
+#          A least one radio is allowing incoming connections.
+#
+#      FALSE
+#          No radios are allowing incoming connections.
+#
+proc BluetoothIsConnectable*(hRadio: HANDLE): BOOL {.stdcall,
+    importc: "BluetoothIsConnectable", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Authentication Registration
+#
+# ***************************************************************************
+type
+  HBLUETOOTH_AUTHENTICATION_REGISTRATION* = HANDLE
+  PFN_AUTHENTICATION_CALLBACK* = proc (pvParam: LPVOID;
+      pDevice: PBLUETOOTH_DEVICE_INFO): BOOL {.stdcall.}
+#
+#  Description:
+#      Registers a callback function to be called when a particular device
+#      requests authentication. The request is sent to the last application
+#      that requested authentication for a particular device.
+#
+#  Parameters:
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure. The Bluetooth
+#          address will be used for comparision.
+#
+#      phRegHandle
+#          A pointer to where the registration HANDLE value will be
+#          stored. Call BluetoothUnregisterAuthentication() to close
+#          the handle.
+#
+#      pfnCallback
+#          The function that will be called when the authentication event
+#          occurs. This function should match PFN_AUTHENTICATION_CALLBACK's
+#          prototype.
+#
+#      pvParam
+#          Optional parameter to be past through to the callback function.
+#          This can be anything the application was to define.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          Success. A valid registration handle was returned.
+#
+#      ERROR_OUTOFMEMORY
+#          Out of memory.
+#
+#      other Win32 error.
+#          Failure. The registration handle is invalid.
+#
+proc BluetoothRegisterForAuthentication*(pbtdi: ptr BLUETOOTH_DEVICE_INFO;
+    phRegHandle: ptr HBLUETOOTH_AUTHENTICATION_REGISTRATION;
+    pfnCallback: PFN_AUTHENTICATION_CALLBACK; pvParam: PVOID): DWORD {.
+    stdcall, importc: "BluetoothRegisterForAuthentication",
+    dynlib: libbluetooth,
+    deprecated.}
+#
+# Support added in KB942567
+#
+#
+# Replaces previous API
+#
+type
+  PFN_AUTHENTICATION_CALLBACK_EX* = proc (pvParam: LPVOID;
+      pAuthCallbackParams: PBLUETOOTH_AUTHENTICATION_CALLBACK_PARAMS): BOOL {.
+      stdcall.}
+#
+#  Description:
+#      Registers a callback function to be called when a particular device
+#      requests authentication. The request is sent to the last application
+#      that requested authentication for a particular device.
+#
+#  Parameters:
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure. The Bluetooth
+#          address will be used for comparision.
+#
+#      phRegHandle
+#          A pointer to where the registration HANDLE value will be
+#          stored. Call BluetoothUnregisterAuthentication() to close
+#          the handle.
+#
+#      pfnCallback
+#          The function that will be called when the authentication event
+#          occurs. This function should match PFN_AUTHENTICATION_CALLBACK_EX's
+#          prototype.
+#
+#      pvParam
+#          Optional parameter to be past through to the callback function.
+#          This can be anything the application was to define.
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          Success. A valid registration handle was returned.
+#
+#      ERROR_OUTOFMEMORY
+#          Out of memory.
+#
+#      other Win32 error.
+#          Failure. The registration handle is invalid.
+#
+proc BluetoothRegisterForAuthenticationEx*(
+    pbtdiIn: ptr BLUETOOTH_DEVICE_INFO;
+    phRegHandleOut: ptr HBLUETOOTH_AUTHENTICATION_REGISTRATION;
+    pfnCallbackIn: PFN_AUTHENTICATION_CALLBACK_EX; pvParam: PVOID): DWORD {.
+    stdcall, importc: "BluetoothRegisterForAuthenticationEx",
+    dynlib: libbluetooth.}
+#
+#  Description:
+#      Unregisters an authentication callback and closes the handle. See
+#      BluetoothRegisterForAuthentication() for more information about
+#      authentication registration.
+#
+#  Parameters:
+#      hRegHandle
+#          Handle returned by BluetoothRegisterForAuthentication().
+#
+#  Return Value:
+#      TRUE
+#          The handle was successfully closed.
+#
+#      FALSE
+#          The handle was not successfully closed. Check GetLastError for
+#          more details.
+#
+#          ERROR_INVALID_HANDLE
+#              The handle is NULL.
+#
+#          other Win32 errors.
+#
+proc BluetoothUnregisterAuthentication*(
+    hRegHandle: HBLUETOOTH_AUTHENTICATION_REGISTRATION): BOOL {.stdcall,
+    importc: "BluetoothUnregisterAuthentication", dynlib: libbluetooth.}
+#
+#  Description:
+#      This function should be called after receiving an authentication request
+#      to send the passkey response.
+#
+#  Parameters:
+#
+#      hRadio
+#          Optional handle to the local radio. If NULL, the function will try
+#          each radio until one succeeds.
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure describing the device
+#          being authenticated. This can be the same structure passed to the
+#          callback function.
+#
+#      pszPasskey
+#          A pointer to UNICODE zero-terminated string of the passkey response
+#          that should be sent back to the authenticating device.
+#
+#  Return Values:
+#      ERROR_SUCESS
+#          The device accepted the passkey response. The device is authenticated.
+#
+#      ERROR_CANCELED
+#          The device denied the passkey reponse. This also will returned if there
+#          is a communications problem with the local radio.
+#
+#      E_FAIL
+#          The device returned a failure code during authentication.
+#
+#      other Win32 error codes
+#
+proc BluetoothSendAuthenticationResponse*(hRadio: HANDLE;
+    pbtdi: ptr BLUETOOTH_DEVICE_INFO; pszPasskey: LPCWSTR): DWORD {.stdcall,
+    importc: "BluetoothSendAuthenticationResponse", dynlib: libbluetooth,
+    deprecated.}
+#
+# Support added in KB942567
+#
+#
+# Replaces previous API
+#
+#
+# Structure used when responding to BTH_REMOTE_AUTHENTICATE_REQUEST event
+#
+type
+  INNER_C_UNION_1965546500* = object  {.union.}
+    pinInfo*: BLUETOOTH_PIN_INFO
+    oobInfo*: BLUETOOTH_OOB_DATA_INFO
+    numericCompInfo*: BLUETOOTH_NUMERIC_COMPARISON_INFO
+    passkeyInfo*: BLUETOOTH_PASSKEY_INFO
+
+type
+  BLUETOOTH_AUTHENTICATE_RESPONSE* = object
+    bthAddressRemote*: BLUETOOTH_ADDRESS
+    authMethod*: BLUETOOTH_AUTHENTICATION_METHOD
+    ano_660658457*: INNER_C_UNION_1965546500
+    negativeResponse*: UCHAR
+
+  PBLUETOOTH_AUTHENTICATE_RESPONSE* = ptr BLUETOOTH_AUTHENTICATE_RESPONSE
+#
+#  Description:
+#      This function should be called after receiving an authentication request
+#      to send the authentication response. (Bluetooth 2.1 and above)
+#
+#  Parameters:
+#
+#      hRadio
+#          Optional handle to the local radio. If NULL, the function will try
+#          each radio until one succeeds.
+#
+#      pbtdi
+#          A pointer to a BLUETOOTH_DEVICE_INFO structure describing the device
+#          being authenticated. This can be the same structure passed to the
+#          callback function.
+#
+#      pauthResponse
+#          A pointer to a BTH_AUTHENTICATION_RESPONSE structure.
+#
+#  Return Values:
+#      ERROR_SUCESS
+#          The device accepted the passkey response. The device is authenticated.
+#
+#      ERROR_CANCELED
+#          The device denied the passkey reponse. This also will returned if there
+#          is a communications problem with the local radio.
+#
+#      E_FAIL
+#          The device returned a failure code during authentication.
+#
+#      other Win32 error codes
+#
+proc BluetoothSendAuthenticationResponseEx*(hRadioIn: HANDLE;
+    pauthResponse: PBLUETOOTH_AUTHENTICATE_RESPONSE): DWORD {.stdcall,
+    importc: "BluetoothSendAuthenticationResponseEx", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  SDP Parsing Functions
+#
+# ***************************************************************************
+type
+  INNER_C_STRUCT_3139021411* = object
+    value*: LPBYTE # raw string buffer, may not be encoded as ANSI, use
+                   # BluetoothSdpGetString to convert the value if it is described
+                   # by the base language attribute ID list
+    # raw length of the string, may not be NULL terminuated
+    length*: ULONG
+
+type
+  INNER_C_STRUCT_467337881* = object
+    value*: LPBYTE
+    length*: ULONG
+
+type
+  INNER_C_STRUCT_4155600511* = object
+    value*: LPBYTE        # raw sequence, starts at sequence element header
+    # raw sequence length
+    length*: ULONG
+
+type
+  INNER_C_STRUCT_1234813489* = object
+    value*: LPBYTE        # raw alternative, starts at alternative element header
+    # raw alternative length
+    length*: ULONG
+
+type
+  INNER_C_UNION_122694421* = object  {.union.}
+    int128*: SDP_LARGE_INTEGER_16 # type == SDP_TYPE_INT
+    # specificType == SDP_ST_INT128
+    int64*: LONGLONG      # specificType == SDP_ST_INT64
+    int32*: LONG          # specificType == SDP_ST_INT32
+    int16*: SHORT         # specificType == SDP_ST_INT16
+    int8*: CHAR           # specificType == SDP_ST_INT8
+                          # type == SDP_TYPE_UINT
+    uint128*: SDP_ULARGE_INTEGER_16 # specificType == SDP_ST_UINT128
+    uint64*: ULONGLONG    # specificType == SDP_ST_UINT64
+    uint32*: ULONG        # specificType == SDP_ST_UINT32
+    uint16*: USHORT       # specificType == SDP_ST_UINT16
+    uint8*: UCHAR         # specificType == SDP_ST_UINT8
+                          # type == SDP_TYPE_BOOLEAN
+    booleanVal*: UCHAR    # type == SDP_TYPE_UUID
+    uuid128*: GUID        # specificType == SDP_ST_UUID128
+    uuid32*: ULONG        # specificType == SDP_ST_UUID32
+    uuid16*: USHORT       # specificType == SDP_ST_UUID32
+                          # type == SDP_TYPE_STRING
+    string*: INNER_C_STRUCT_3139021411 # type == SDP_TYPE_URL
+    url*: INNER_C_STRUCT_467337881 # type == SDP_TYPE_SEQUENCE
+    sequence*: INNER_C_STRUCT_4155600511 # type == SDP_TYPE_ALTERNATIVE
+    alternative*: INNER_C_STRUCT_1234813489
+
+type
+  SDP_ELEMENT_DATA* = object
+    `type`*: SDP_TYPE #
+                      # Enumeration of SDP element types.  Generic element types will have a
+                      # specificType value other then SDP_ST_NONE.  The generic types are:
+                      # o SDP_TYPE_UINT
+                      # o SDP_TYPE_INT
+                      # o SDP_TYPE_UUID
+                      #
+    #
+    # Specific types for the generic SDP element types.
+    #
+    specificType*: SDP_SPECIFICTYPE #
+                                    # Union of all possible data types.  type and specificType will indicate
+                                    # which field is valid.  For types which do not have a valid specificType,
+                                    # specific type will be SDP_ST_NONE.
+                                    #
+    data*: INNER_C_UNION_122694421
+
+  PSDP_ELEMENT_DATA* = ptr SDP_ELEMENT_DATA
+#
+# Description:
+#      Retrieves and parses the element found at pSdpStream
+#
+# Parameters:
+#      IN pSdpStream
+#          pointer to valid SDP stream
+#
+#      IN cbSdpStreamLength
+#          length of pSdpStream in bytes
+#
+#      OUT pData
+#          pointer to be filled in with the data of the SDP element at the
+#          beginning of pSdpStream
+#
+# Return Values:
+#      ERROR_INVALID_PARAMETER
+#          one of required parameters is NULL or the pSdpStream is invalid
+#
+#      ERROR_SUCCESS
+#          the sdp element was parsed correctly
+#
+proc BluetoothSdpGetElementData*(pSdpStream: LPBYTE;
+                                 cbSdpStreamLength: ULONG;
+                                 pData: PSDP_ELEMENT_DATA): DWORD {.stdcall,
+    importc: "BluetoothSdpGetElementData", dynlib: libbluetooth.}
+type
+  HBLUETOOTH_CONTAINER_ELEMENT* = HANDLE
+#
+# Description:
+#      Iterates over a container stream, returning each elemetn contained with
+#      in the container element at the beginning of pContainerStream
+#
+# Parameters:
+#      IN pContainerStream
+#          pointer to valid SDP stream whose first element is either a sequence
+#          or alternative
+#
+#      IN cbContainerlength
+#          length in bytes of pContainerStream
+#
+#      IN OUT pElement
+#          Value used to keep track of location within the stream.  The first
+#          time this function is called for a particular container, *pElement
+#          should equal NULL.  Upon subsequent calls, the value should be
+#          unmodified.
+#
+#      OUT pData
+#          pointer to be filled in with the data of the SDP element at the
+#          current element of pContainerStream
+#
+#  Return Values:
+#      ERROR_SUCCESS
+#          The call succeeded, pData contains the data
+#
+#      ERROR_NO_MORE_ITEMS
+#          There are no more items in the list, the caller should cease calling
+#          BluetoothSdpGetContainerElementData for this container.
+#
+#      ERROR_INVALID_PARAMETER
+#          A required pointer is NULL or the container is not a valid SDP
+#          stream
+#
+# Usage example:
+#
+# HBLUETOOTH_CONTAINER_ELEMENT element;
+# SDP_ELEMENT_DATA data;
+# ULONG result;
+#
+# element = NULL;
+#
+# while (TRUE) {
+#      result = BluetoothSdpGetContainerElementData(
+#          pContainer, ulContainerLength, &element, &data);
+#
+#      if (result == ERROR_NO_MORE_ITEMS) {
+#          // We are done
+#          break;
+#      }
+#      else if (result != ERROR_SUCCESS) {
+#          // error
+#      }
+#
+#      // do something with data ...
+# }
+#
+#
+proc BluetoothSdpGetContainerElementData*(pContainerStream: LPBYTE;
+    cbContainerLength: ULONG; pElement: ptr HBLUETOOTH_CONTAINER_ELEMENT;
+    pData: PSDP_ELEMENT_DATA): DWORD {.stdcall,
+    importc: "BluetoothSdpGetContainerElementData", dynlib: libbluetooth.}
+#
+# Description:
+#      Retrieves the attribute value for the given attribute ID.  pRecordStream
+#      must be an SDP stream that is formatted as an SDP record, a SEQUENCE
+#      containing UINT16 + element pairs.
+#
+# Parameters:
+#      IN pRecordStream
+#          pointer to a valid SDP stream which is formatted as a singl SDP
+#          record
+#
+#      IN cbRecordlnegh
+#          length of pRecordStream in bytes
+#
+#      IN usAttributeId
+#          the attribute ID to search for.  see bthdef.h for SDP_ATTRIB_Xxx
+#          values.
+#
+#      OUT pAttributeData
+#          pointer that will contain the attribute ID's value
+#
+# Return Values:
+#      ERRROR_SUCCESS
+#          Call succeeded, pAttributeData contains the attribute value
+#
+#      ERROR_INVALID_PARAMETER
+#          One of the required pointers was NULL, pRecordStream was not a valid
+#          SDP stream, or pRecordStream was not a properly formatted SDP record
+#
+#      ERROR_FILE_NOT_FOUND
+#          usAttributeId was not found in the record
+#
+# Usage:
+#
+# ULONG result;
+# SDP_DATA_ELEMENT data;
+#
+# result = BluetoothSdpGetAttributeValue(
+#      pRecordStream, cbRecordLength, SDP_ATTRIB_RECORD_HANDLE, &data);
+# if (result == ERROR_SUCCESS) {
+#      printf("record handle is 0x%x\n", data.data.uint32);
+# }
+#
+proc BluetoothSdpGetAttributeValue*(pRecordStream: LPBYTE;
+                                    cbRecordLength: ULONG;
+                                    usAttributeId: USHORT;
+                                    pAttributeData: PSDP_ELEMENT_DATA): DWORD {.
+    stdcall, importc: "BluetoothSdpGetAttributeValue", dynlib: libbluetooth.}
+#
+# These three fields correspond one to one with the triplets defined in the
+# SDP specification for the language base attribute ID list.
+#
+type
+  SDP_STRING_TYPE_DATA* = object
+    encoding*: USHORT #
+                      # How the string is encoded according to ISO 639:1988 (E/F): "Code
+                      # for the representation of names of languages".
+                      #
+    #
+    # MIBE number from IANA database
+    #
+    mibeNum*: USHORT #
+                     # The base attribute where the string is to be found in the record
+                     #
+    attributeId*: USHORT
+
+  PSDP_STRING_TYPE_DATA* = ptr SDP_STRING_TYPE_DATA
+#
+# Description:
+#      Converts a raw string embedded in the SDP record into a UNICODE string
+#
+# Parameters:
+#      IN pRecordStream
+#          a valid SDP stream which is formatted as an SDP record
+#
+#      IN cbRecordLength
+#          length of pRecordStream in bytes
+#
+#      IN pStringData
+#          if NULL, then the calling thread's locale will be used to search
+#          for a matching string in the SDP record.  If not NUL, the mibeNum
+#          and attributeId will be used to find the string to convert.
+#
+#      IN usStringOffset
+#          the SDP string type offset to convert.  usStringOffset is added to
+#          the base attribute id of the string.   SDP specification defined
+#          offsets are: STRING_NAME_OFFSET, STRING_DESCRIPTION_OFFSET, and
+#          STRING_PROVIDER_NAME_OFFSET (found in bthdef.h).
+#
+#      OUT pszString
+#          if NULL, pcchStringLength will be filled in with the required number
+#          of characters (not bytes) to retrieve the converted string.
+#
+#      IN OUT pcchStringLength
+#          Upon input, if pszString is not NULL, will contain the length of
+#          pszString in characters.  Upon output, it will contain either the
+#          number of required characters including NULL if an error is returned
+#          or the number of characters written to pszString (including NULL).
+#
+#  Return Values:
+#      ERROR_SUCCES
+#          Call was successful and pszString contains the converted string
+#
+#      ERROR_MORE_DATA
+#          pszString was NULL or too small to contain the converted string,
+#          pccxhStringLength contains the required length in characters
+#
+#      ERROR_INVALID_DATA
+#          Could not perform the conversion
+#
+#      ERROR_NO_SYSTEM_RESOURCES
+#          Could not allocate memory internally to perform the conversion
+#
+#      ERROR_INVALID_PARAMETER
+#          One of the rquired pointers was NULL, pRecordStream was not a valid
+#          SDP stream, pRecordStream was not a properly formatted record, or
+#          the desired attribute + offset was not a string.
+#
+#      Other HRESULTs returned by COM
+#
+proc BluetoothSdpGetString*(pRecordStream: LPBYTE; cbRecordLength: ULONG;
+                            pStringData: PSDP_STRING_TYPE_DATA;
+                            usStringOffset: USHORT; pszString: PWSTR;
+                            pcchStringLength: PULONG): DWORD {.stdcall,
+    importc: "BluetoothSdpGetString", dynlib: libbluetooth.}
+# ***************************************************************************
+#
+#  Raw Attribute  Enumeration
+#
+# ***************************************************************************
+type
+  PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK* = proc (uAttribId: ULONG;
+      pValueStream: LPBYTE; cbStreamSize: ULONG; pvParam: LPVOID): BOOL {.
+      stdcall.}
+#
+#  Description:
+#      Enumerates through the SDP record stream calling the Callback function
+#      for each attribute in the record. If the Callback function returns
+#      FALSE, the enumeration is stopped.
+#
+#  Return Values:
+#      TRUE
+#          Success! Something was enumerated.
+#
+#      FALSE
+#          Failure. GetLastError() could be one of the following:
+#
+#          ERROR_INVALID_PARAMETER
+#              pSDPStream or pfnCallback is NULL.
+#
+#          ERROR_INVALID_DATA
+#              The SDP stream is corrupt.
+#
+#          other Win32 errors.
+#
+proc BluetoothSdpEnumAttributes*(pSDPStream: LPBYTE; cbStreamSize: ULONG;
+    pfnCallback: PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK; pvParam: LPVOID): BOOL {.
+    stdcall, importc: "BluetoothSdpEnumAttributes", dynlib: libbluetooth.}
+const
+  BluetoothEnumAttributes* = BluetoothSdpEnumAttributes
+#
+# The following APIs are only available on Vista or later
+#
+proc BluetoothSetLocalServiceInfo*(hRadioIn: HANDLE; pClassGuid: ptr GUID;
+                                   ulInstance: ULONG; pServiceInfoIn: ptr BLUETOOTH_LOCAL_SERVICE_INFO): DWORD {.
+    stdcall, importc: "BluetoothSetLocalServiceInfo", dynlib: libbluetooth.}
+
+#
+# Support added in KB942567
+#
+
+#
+# IsBluetoothVersionAvailable
+#
+# Description:
+#      Indicate if the installed Bluetooth binary set supports
+#      the requested version
+#
+# Return Values:
+#      TRUE if the installed bluetooth binaries support the given
+#      Major & Minor versions
+#
+# Note this function is only exported in version 2.1 and later.
+#
+proc BluetoothIsVersionAvailable*(MajorVersion: UCHAR; MinorVersion: UCHAR): BOOL {.
+    stdcall, importc: "BluetoothIsVersionAvailable", dynlib: libbluetooth.}