@bun-win32/bluetoothapis 1.0.0

package/AI.md

@@ -0,0 +1,71 @@
+# AI Guide for @bun-win32/bluetoothapis
+
+How to use this package, not what the Win32 API does.
+
+## Usage
+
+```ts
+import BluetoothApis, { BLUETOOTH_SERVICE_ENABLE } from '@bun-win32/bluetoothapis';
+
+// Methods bind lazily on first call
+const isDiscoverable = BluetoothApis.BluetoothIsDiscoverable(0n);
+
+// Preload: array, single string, or no args (all symbols)
+BluetoothApis.Preload(['BluetoothFindFirstRadio', 'BluetoothFindNextRadio']);
+BluetoothApis.Preload('BluetoothGetRadioInfo');
+BluetoothApis.Preload();
+```
+
+## Where To Look
+
+| Need                              | Read                        |
+| --------------------------------- | --------------------------- |
+| Find a method or its MS Docs link | `structs/BluetoothApis.ts`  |
+| Find types, enums, constants      | `types/BluetoothApis.ts`    |
+| Quick examples                    | `README.md`                 |
+
+`index.ts` re-exports the class and all types — import from `@bun-win32/bluetoothapis` directly.
+
+## Calling Convention
+
+All documented `bluetoothapis.dll` exports are bound. Each method maps 1:1 to its DLL export. Names, parameter names, and order match Microsoft Docs.
+
+### Strings
+
+`W` methods take UTF-16LE NUL-terminated buffers. `A` methods take ANSI strings.
+
+```ts
+const wide = Buffer.from('Hello\0', 'utf16le');  // LPCWSTR
+BluetoothApis.BluetoothSendAuthenticationResponse(0n, pbtdi, wide.ptr);
+
+// Reading a wide string back from a buffer:
+const text = new TextDecoder('utf-16').decode(buf).replace(/\0.*$/, '');
+```
+
+### Return types
+
+- `HANDLE`, `HWND`, etc. → `bigint`
+- `DWORD`, `UINT`, `BOOL`, `INT`, `LONG` → `number`
+- `LPVOID`, `LPWSTR`, etc. → `Pointer`
+- Win32 `BOOL` is `number` (0 or non-zero), **not** JS `boolean`. Do not compare with `=== true`.
+
+### Pointers, handles, out-parameters
+
+- **Pointer** params (`LP*`, `P*`, `Pointer`): pass `buffer.ptr` from a caller-allocated `Buffer`.
+- **Handle** params (`HANDLE`, `HWND`, etc.): pass a `bigint` value.
+- **Out-parameters**: allocate a `Buffer`, pass `.ptr`, read the result after the call.
+
+```ts
+const out = Buffer.alloc(8);
+BluetoothApis.BluetoothFindFirstRadio(params.ptr, out.ptr);
+const hRadio = out.readBigUInt64LE(0);
+```
+
+### Nullability
+
+- `| NULL` in a signature → pass `null` (optional pointer).
+- `| 0n` in a signature → pass `0n` (optional handle).
+
+## Errors and Cleanup
+
+Return values are raw. If the Win32 function uses last-error semantics, read via `GetLastError()`. Resource cleanup is your responsibility — same as raw Win32.

package/README.md

@@ -0,0 +1,76 @@
+# @bun-win32/bluetoothapis
+
+Zero-dependency, zero-overhead Win32 BluetoothApis bindings for [Bun](https://bun.sh) on Windows.
+
+## Overview
+
+`@bun-win32/bluetoothapis` exposes the `bluetoothapis.dll` exports using [Bun](https://bun.sh)'s FFI. It provides a single class, `BluetoothApis`, which lazily binds native symbols on first use. You can optionally preload a subset or all symbols up-front via `Preload()`.
+
+The bindings are strongly typed for a smooth DX in TypeScript.
+
+## Features
+
+- [Bun](https://bun.sh)-first ergonomics on Windows 10/11.
+- Direct FFI to `bluetoothapis.dll` (Bluetooth Classic radio/device discovery, BLE GATT, SDP, authentication).
+- In-source docs in `structs/BluetoothApis.ts` with links to Microsoft Docs.
+- Lazy binding on first call; optional eager preload (`BluetoothApis.Preload()`).
+- No wrapper overhead; calls map 1:1 to native APIs.
+- Strongly-typed Win32 aliases (see `types/BluetoothApis.ts`).
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+- Windows 10 or later
+
+## Installation
+
+```sh
+bun add @bun-win32/bluetoothapis
+```
+
+## Quick Start
+
+```ts
+import BluetoothApis from '@bun-win32/bluetoothapis';
+import Kernel32 from '@bun-win32/kernel32';
+
+// BLUETOOTH_FIND_RADIO_PARAMS: { dwSize: DWORD }
+const params = Buffer.alloc(4);
+params.writeUInt32LE(4, 0);
+
+const hRadio = Buffer.alloc(8);
+const hFind = BluetoothApis.BluetoothFindFirstRadio(params.ptr, hRadio.ptr);
+
+if (hFind !== 0n) {
+  const radioHandle = hRadio.readBigUInt64LE(0);
+  console.log('Found radio handle:', radioHandle);
+
+  // Get radio info
+  const radioInfo = Buffer.alloc(520); // BLUETOOTH_RADIO_INFO size
+  radioInfo.writeUInt32LE(520, 0);     // dwSize
+  const err = BluetoothApis.BluetoothGetRadioInfo(radioHandle, radioInfo.ptr);
+  if (err === 0) {
+    const name = new TextDecoder('utf-16le').decode(radioInfo.subarray(264, 264 + 496)).replace(/\0.*$/, '');
+    console.log('Radio name:', name);
+  }
+
+  Kernel32.CloseHandle(radioHandle);
+  BluetoothApis.BluetoothFindRadioClose(hFind);
+}
+```
+
+> [!NOTE]
+> AI agents: see `AI.md` for the package binding contract and source-navigation guidance. It explains how to use the package without scanning the entire implementation.
+
+## Examples
+
+Run the included examples:
+
+```sh
+cd packages/bluetoothapis && bun run example/bluetoothapis.ts
+```
+
+## Notes
+
+- Either rely on lazy binding or call `BluetoothApis.Preload()`.
+- Windows only. Bun runtime required.

package/index.ts

@@ -0,0 +1,4 @@
+import BluetoothApis from './structs/BluetoothApis';
+
+export * from './types/BluetoothApis';
+export default BluetoothApis;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "author": "Stev Peifer <stev@bell.net>",
+  "bugs": {
+    "url": "https://github.com/ObscuritySRL/bun-win32/issues"
+  },
+  "dependencies": {
+    "@bun-win32/core": "1.1.1"
+  },
+  "description": "Zero-dependency, zero-overhead Win32 BLUETOOTHAPIS bindings for Bun (FFI) on Windows.",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "module": "index.ts",
+  "name": "@bun-win32/bluetoothapis",
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "private": false,
+  "homepage": "https://github.com/ObscuritySRL/bun-win32#readme",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ObscuritySRL/bun-win32.git",
+    "directory": "packages/bluetoothapis"
+  },
+  "type": "module",
+  "version": "1.0.0",
+  "main": "./index.ts",
+  "keywords": [
+    "bun",
+    "ffi",
+    "win32",
+    "windows",
+    "bluetoothapis",
+    "bluetooth",
+    "ble",
+    "gatt",
+    "bindings",
+    "typescript",
+    "dll"
+  ],
+  "files": [
+    "AI.md",
+    "README.md",
+    "index.ts",
+    "structs/*.ts",
+    "types/*.ts"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "example": "bun ./example/bluetoothapis.ts"
+  }
+}

package/structs/BluetoothApis.ts

@@ -0,0 +1,379 @@
+import { type FFIFunction, FFIType } from 'bun:ffi';
+
+import { Win32 } from '@bun-win32/core';
+
+import type {
+  BLUETOOTH_GATT_EVENT_HANDLE,
+  BOOL,
+  BTH_LE_GATT_EVENT_TYPE,
+  BTH_LE_GATT_RELIABLE_WRITE_CONTEXT,
+  DWORD,
+  HANDLE,
+  HBLUETOOTH_AUTHENTICATION_REGISTRATION,
+  HBLUETOOTH_DEVICE_FIND,
+  HBLUETOOTH_RADIO_FIND,
+  HRESULT,
+  LPBYTE,
+  LPCWSTR,
+  LPDWORD,
+  LPVOID,
+  LPWSTR,
+  NULL,
+  PBLUETOOTH_ADDRESS,
+  PBLUETOOTH_AUTHENTICATE_RESPONSE,
+  PBLUETOOTH_DEVICE_INFO,
+  PBLUETOOTH_DEVICE_SEARCH_PARAMS,
+  PBLUETOOTH_FIND_RADIO_PARAMS,
+  PBLUETOOTH_GATT_EVENT_HANDLE,
+  PBLUETOOTH_LOCAL_SERVICE_INFO,
+  PBLUETOOTH_RADIO_INFO,
+  PBTH_LE_GATT_CHARACTERISTIC,
+  PBTH_LE_GATT_CHARACTERISTIC_VALUE,
+  PBTH_LE_GATT_DESCRIPTOR,
+  PBTH_LE_GATT_DESCRIPTOR_VALUE,
+  PBTH_LE_GATT_RELIABLE_WRITE_CONTEXT,
+  PBTH_LE_GATT_SERVICE,
+  PFNBLUETOOTH_GATT_EVENT_CALLBACK,
+  PFN_AUTHENTICATION_CALLBACK,
+  PFN_AUTHENTICATION_CALLBACK_EX,
+  PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK,
+  PGUID,
+  PHANDLE,
+  PHBLUETOOTH_AUTHENTICATION_REGISTRATION,
+  PHBLUETOOTH_CONTAINER_ELEMENT,
+  PSDP_ELEMENT_DATA,
+  PSDP_STRING_TYPE_DATA,
+  PULONG,
+  PUSHORT,
+  PVOID,
+  UCHAR,
+  ULONG,
+  USHORT,
+} from '../types/BluetoothApis';
+
+/**
+ * Thin, lazy-loaded FFI bindings for `bluetoothapis.dll`.
+ *
+ * Each static method corresponds one-to-one with a Win32 export declared in `Symbols`.
+ * The first call to a method binds the underlying native symbol via `bun:ffi` and
+ * memoizes it on the class for subsequent calls. For bulk, up-front binding, use `Preload`.
+ *
+ * Symbols are defined with explicit `FFIType` signatures and kept alphabetized.
+ * You normally do not access `Symbols` directly; call the static methods or preload
+ * a subset for hot paths.
+ *
+ * @example
+ * ```ts
+ * import BluetoothApis from './structs/BluetoothApis';
+ *
+ * // Lazy: bind on first call
+ * const hFind = BluetoothApis.BluetoothFindFirstRadio(params.ptr, hRadio.ptr);
+ *
+ * // Or preload a subset to avoid per-symbol lazy binding cost
+ * BluetoothApis.Preload(['BluetoothFindFirstRadio', 'BluetoothFindNextRadio']);
+ * ```
+ */
+class BluetoothApis extends Win32 {
+  protected static override name = 'bluetoothapis.dll';
+
+  /** @inheritdoc */
+  protected static override readonly Symbols = {
+    BluetoothEnableDiscovery: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+    BluetoothEnableIncomingConnections: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+    BluetoothEnumerateInstalledServices: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothFindDeviceClose: { args: [FFIType.u64], returns: FFIType.i32 },
+    BluetoothFindFirstDevice: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
+    BluetoothFindFirstRadio: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
+    BluetoothFindNextDevice: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    BluetoothFindNextRadio: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    BluetoothFindRadioClose: { args: [FFIType.u64], returns: FFIType.i32 },
+    BluetoothGATTAbortReliableWrite: { args: [FFIType.u64, FFIType.u64, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTBeginReliableWrite: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTEndReliableWrite: { args: [FFIType.u64, FFIType.u64, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetCharacteristicValue: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetCharacteristics: { args: [FFIType.u64, FFIType.ptr, FFIType.u16, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetDescriptorValue: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetDescriptors: { args: [FFIType.u64, FFIType.ptr, FFIType.u16, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetIncludedServices: { args: [FFIType.u64, FFIType.ptr, FFIType.u16, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTGetServices: { args: [FFIType.u64, FFIType.u16, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTRegisterEvent: { args: [FFIType.u64, FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTSetCharacteristicValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTSetDescriptorValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGATTUnregisterEvent: { args: [FFIType.u64, FFIType.u32], returns: FFIType.i32 },
+    BluetoothGetDeviceInfo: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothGetRadioInfo: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothIsConnectable: { args: [FFIType.u64], returns: FFIType.i32 },
+    BluetoothIsDiscoverable: { args: [FFIType.u64], returns: FFIType.i32 },
+    BluetoothIsVersionAvailable: { args: [FFIType.u8, FFIType.u8], returns: FFIType.i32 },
+    BluetoothRegisterForAuthentication: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothRegisterForAuthenticationEx: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothRemoveDevice: { args: [FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSdpEnumAttributes: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    BluetoothSdpGetAttributeValue: { args: [FFIType.ptr, FFIType.u32, FFIType.u16, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSdpGetContainerElementData: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSdpGetElementData: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSdpGetString: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u16, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSendAuthenticationResponse: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSendAuthenticationResponseEx: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSetLocalServiceInfo: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.u32 },
+    BluetoothSetServiceState: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    BluetoothUnregisterAuthentication: { args: [FFIType.u64], returns: FFIType.i32 },
+    BluetoothUpdateDeviceRecord: { args: [FFIType.ptr], returns: FFIType.u32 },
+  } as const satisfies Record<string, FFIFunction>;
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothenablediscovery
+  public static BluetoothEnableDiscovery(hRadio: HANDLE | 0n, fEnabled: BOOL): BOOL {
+    return BluetoothApis.Load('BluetoothEnableDiscovery')(hRadio, fEnabled);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothenableincomingconnections
+  public static BluetoothEnableIncomingConnections(hRadio: HANDLE | 0n, fEnabled: BOOL): BOOL {
+    return BluetoothApis.Load('BluetoothEnableIncomingConnections')(hRadio, fEnabled);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothenumerateinstalledservices
+  public static BluetoothEnumerateInstalledServices(hRadio: HANDLE | 0n, pbtdi: PBLUETOOTH_DEVICE_INFO, pcServiceInout: LPDWORD, pGuidServices: PGUID | NULL): DWORD {
+    return BluetoothApis.Load('BluetoothEnumerateInstalledServices')(hRadio, pbtdi, pcServiceInout, pGuidServices);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfinddeviceclose
+  public static BluetoothFindDeviceClose(hFind: HBLUETOOTH_DEVICE_FIND): BOOL {
+    return BluetoothApis.Load('BluetoothFindDeviceClose')(hFind);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfindfirstdevice
+  public static BluetoothFindFirstDevice(pbtsp: PBLUETOOTH_DEVICE_SEARCH_PARAMS, pbtdi: PBLUETOOTH_DEVICE_INFO): HBLUETOOTH_DEVICE_FIND {
+    return BluetoothApis.Load('BluetoothFindFirstDevice')(pbtsp, pbtdi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfindfirstradio
+  public static BluetoothFindFirstRadio(pbtfrp: PBLUETOOTH_FIND_RADIO_PARAMS, phRadio: PHANDLE): HBLUETOOTH_RADIO_FIND {
+    return BluetoothApis.Load('BluetoothFindFirstRadio')(pbtfrp, phRadio);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfindnextdevice
+  public static BluetoothFindNextDevice(hFind: HBLUETOOTH_DEVICE_FIND, pbtdi: PBLUETOOTH_DEVICE_INFO): BOOL {
+    return BluetoothApis.Load('BluetoothFindNextDevice')(hFind, pbtdi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfindnextradio
+  public static BluetoothFindNextRadio(hFind: HBLUETOOTH_RADIO_FIND, phRadio: PHANDLE): BOOL {
+    return BluetoothApis.Load('BluetoothFindNextRadio')(hFind, phRadio);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothfindradioclose
+  public static BluetoothFindRadioClose(hFind: HBLUETOOTH_RADIO_FIND): BOOL {
+    return BluetoothApis.Load('BluetoothFindRadioClose')(hFind);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattabortreliablewrite
+  public static BluetoothGATTAbortReliableWrite(hDevice: HANDLE, ReliableWriteContext: BTH_LE_GATT_RELIABLE_WRITE_CONTEXT, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTAbortReliableWrite')(hDevice, ReliableWriteContext, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattbeginreliablewrite
+  public static BluetoothGATTBeginReliableWrite(hDevice: HANDLE, ReliableWriteContext: PBTH_LE_GATT_RELIABLE_WRITE_CONTEXT, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTBeginReliableWrite')(hDevice, ReliableWriteContext, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattendreliablewrite
+  public static BluetoothGATTEndReliableWrite(hDevice: HANDLE, ReliableWriteContext: BTH_LE_GATT_RELIABLE_WRITE_CONTEXT, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTEndReliableWrite')(hDevice, ReliableWriteContext, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetcharacteristicvalue
+  public static BluetoothGATTGetCharacteristicValue(
+    hDevice: HANDLE,
+    Characteristic: PBTH_LE_GATT_CHARACTERISTIC,
+    CharacteristicValueDataSize: ULONG,
+    CharacteristicValue: PBTH_LE_GATT_CHARACTERISTIC_VALUE | NULL,
+    CharacteristicValueSizeRequired: PUSHORT | NULL,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetCharacteristicValue')(hDevice, Characteristic, CharacteristicValueDataSize, CharacteristicValue, CharacteristicValueSizeRequired, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetcharacteristics
+  public static BluetoothGATTGetCharacteristics(
+    hDevice: HANDLE,
+    Service: PBTH_LE_GATT_SERVICE | NULL,
+    CharacteristicsBufferCount: USHORT,
+    CharacteristicsBuffer: PBTH_LE_GATT_CHARACTERISTIC | NULL,
+    CharacteristicsBufferActual: PUSHORT,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetCharacteristics')(hDevice, Service, CharacteristicsBufferCount, CharacteristicsBuffer, CharacteristicsBufferActual, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetdescriptorvalue
+  public static BluetoothGATTGetDescriptorValue(
+    hDevice: HANDLE,
+    Descriptor: PBTH_LE_GATT_DESCRIPTOR,
+    DescriptorValueDataSize: ULONG,
+    DescriptorValue: PBTH_LE_GATT_DESCRIPTOR_VALUE | NULL,
+    DescriptorValueSizeRequired: PUSHORT | NULL,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetDescriptorValue')(hDevice, Descriptor, DescriptorValueDataSize, DescriptorValue, DescriptorValueSizeRequired, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetdescriptors
+  public static BluetoothGATTGetDescriptors(
+    hDevice: HANDLE,
+    Characteristic: PBTH_LE_GATT_CHARACTERISTIC,
+    DescriptorsBufferCount: USHORT,
+    DescriptorsBuffer: PBTH_LE_GATT_DESCRIPTOR | NULL,
+    DescriptorsBufferActual: PUSHORT,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetDescriptors')(hDevice, Characteristic, DescriptorsBufferCount, DescriptorsBuffer, DescriptorsBufferActual, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetincludedservices
+  public static BluetoothGATTGetIncludedServices(
+    hDevice: HANDLE,
+    ParentService: PBTH_LE_GATT_SERVICE | NULL,
+    IncludedServicesBufferCount: USHORT,
+    IncludedServicesBuffer: PBTH_LE_GATT_SERVICE | NULL,
+    IncludedServicesBufferActual: PUSHORT,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetIncludedServices')(hDevice, ParentService, IncludedServicesBufferCount, IncludedServicesBuffer, IncludedServicesBufferActual, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattgetservices
+  public static BluetoothGATTGetServices(hDevice: HANDLE, ServicesBufferCount: USHORT, ServicesBuffer: PBTH_LE_GATT_SERVICE | NULL, ServicesBufferActual: PUSHORT, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTGetServices')(hDevice, ServicesBufferCount, ServicesBuffer, ServicesBufferActual, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattregisterevent
+  public static BluetoothGATTRegisterEvent(
+    hService: HANDLE,
+    EventType: BTH_LE_GATT_EVENT_TYPE,
+    EventParameterIn: PVOID,
+    Callback: PFNBLUETOOTH_GATT_EVENT_CALLBACK,
+    CallbackContext: PVOID | NULL,
+    pEventHandle: PBLUETOOTH_GATT_EVENT_HANDLE,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTRegisterEvent')(hService, EventType, EventParameterIn, Callback, CallbackContext, pEventHandle, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattsetcharacteristicvalue
+  public static BluetoothGATTSetCharacteristicValue(
+    hDevice: HANDLE,
+    Characteristic: PBTH_LE_GATT_CHARACTERISTIC,
+    CharacteristicValue: PBTH_LE_GATT_CHARACTERISTIC_VALUE,
+    ReliableWriteContext: BTH_LE_GATT_RELIABLE_WRITE_CONTEXT | 0n,
+    Flags: ULONG,
+  ): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTSetCharacteristicValue')(hDevice, Characteristic, CharacteristicValue, ReliableWriteContext, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattsetdescriptorvalue
+  public static BluetoothGATTSetDescriptorValue(hDevice: HANDLE, Descriptor: PBTH_LE_GATT_DESCRIPTOR, DescriptorValue: PBTH_LE_GATT_DESCRIPTOR_VALUE, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTSetDescriptorValue')(hDevice, Descriptor, DescriptorValue, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothleapis/nf-bluetoothleapis-bluetoothgattunregisterevent
+  public static BluetoothGATTUnregisterEvent(EventHandle: BLUETOOTH_GATT_EVENT_HANDLE, Flags: ULONG): HRESULT {
+    return BluetoothApis.Load('BluetoothGATTUnregisterEvent')(EventHandle, Flags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothgetdeviceinfo
+  public static BluetoothGetDeviceInfo(hRadio: HANDLE, pbtdi: PBLUETOOTH_DEVICE_INFO): DWORD {
+    return BluetoothApis.Load('BluetoothGetDeviceInfo')(hRadio, pbtdi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothgetradioinfo
+  public static BluetoothGetRadioInfo(hRadio: HANDLE, pRadioInfo: PBLUETOOTH_RADIO_INFO): DWORD {
+    return BluetoothApis.Load('BluetoothGetRadioInfo')(hRadio, pRadioInfo);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothisconnectable
+  public static BluetoothIsConnectable(hRadio: HANDLE | 0n): BOOL {
+    return BluetoothApis.Load('BluetoothIsConnectable')(hRadio);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothisdiscoverable
+  public static BluetoothIsDiscoverable(hRadio: HANDLE | 0n): BOOL {
+    return BluetoothApis.Load('BluetoothIsDiscoverable')(hRadio);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothisversionavailable
+  public static BluetoothIsVersionAvailable(MajorVersion: UCHAR, MinorVersion: UCHAR): BOOL {
+    return BluetoothApis.Load('BluetoothIsVersionAvailable')(MajorVersion, MinorVersion);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothregisterforauthentication
+  public static BluetoothRegisterForAuthentication(pbtdi: PBLUETOOTH_DEVICE_INFO, phRegHandle: PHBLUETOOTH_AUTHENTICATION_REGISTRATION, pfnCallback: PFN_AUTHENTICATION_CALLBACK, pvParam: PVOID | NULL): DWORD {
+    return BluetoothApis.Load('BluetoothRegisterForAuthentication')(pbtdi, phRegHandle, pfnCallback, pvParam);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothregisterforauthenticationex
+  public static BluetoothRegisterForAuthenticationEx(pbtdiIn: PBLUETOOTH_DEVICE_INFO | NULL, phRegHandleOut: PHBLUETOOTH_AUTHENTICATION_REGISTRATION, pfnCallbackIn: PFN_AUTHENTICATION_CALLBACK_EX | NULL, pvParam: PVOID | NULL): DWORD {
+    return BluetoothApis.Load('BluetoothRegisterForAuthenticationEx')(pbtdiIn, phRegHandleOut, pfnCallbackIn, pvParam);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothremovedevice
+  public static BluetoothRemoveDevice(pAddress: PBLUETOOTH_ADDRESS): DWORD {
+    return BluetoothApis.Load('BluetoothRemoveDevice')(pAddress);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsdpenumattributes
+  public static BluetoothSdpEnumAttributes(pSDPStream: LPBYTE, cbStreamSize: ULONG, pfnCallback: PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK, pvParam: LPVOID | NULL): BOOL {
+    return BluetoothApis.Load('BluetoothSdpEnumAttributes')(pSDPStream, cbStreamSize, pfnCallback, pvParam);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsdpgetattributevalue
+  public static BluetoothSdpGetAttributeValue(pRecordStream: LPBYTE, cbRecordLength: ULONG, usAttributeId: USHORT, pAttributeData: PSDP_ELEMENT_DATA): DWORD {
+    return BluetoothApis.Load('BluetoothSdpGetAttributeValue')(pRecordStream, cbRecordLength, usAttributeId, pAttributeData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsdpgetcontainerelementdata
+  public static BluetoothSdpGetContainerElementData(pContainerStream: LPBYTE, cbContainerLength: ULONG, pElement: PHBLUETOOTH_CONTAINER_ELEMENT, pData: PSDP_ELEMENT_DATA): DWORD {
+    return BluetoothApis.Load('BluetoothSdpGetContainerElementData')(pContainerStream, cbContainerLength, pElement, pData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsdpgetelementdata
+  public static BluetoothSdpGetElementData(pSdpStream: LPBYTE, cbSdpStreamLength: ULONG, pData: PSDP_ELEMENT_DATA): DWORD {
+    return BluetoothApis.Load('BluetoothSdpGetElementData')(pSdpStream, cbSdpStreamLength, pData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsdpgetstring
+  public static BluetoothSdpGetString(pRecordStream: LPBYTE, cbRecordLength: ULONG, pStringData: PSDP_STRING_TYPE_DATA | NULL, usStringOffset: USHORT, pszString: LPWSTR | NULL, pcchStringLength: PULONG): DWORD {
+    return BluetoothApis.Load('BluetoothSdpGetString')(pRecordStream, cbRecordLength, pStringData, usStringOffset, pszString, pcchStringLength);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsendauthenticationresponse
+  public static BluetoothSendAuthenticationResponse(hRadio: HANDLE | 0n, pbtdi: PBLUETOOTH_DEVICE_INFO, pszPasskey: LPCWSTR): DWORD {
+    return BluetoothApis.Load('BluetoothSendAuthenticationResponse')(hRadio, pbtdi, pszPasskey);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsendauthenticationresponseex
+  public static BluetoothSendAuthenticationResponseEx(hRadioIn: HANDLE | 0n, pauthResponse: PBLUETOOTH_AUTHENTICATE_RESPONSE): DWORD {
+    return BluetoothApis.Load('BluetoothSendAuthenticationResponseEx')(hRadioIn, pauthResponse);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsetlocalserviceinfo
+  public static BluetoothSetLocalServiceInfo(hRadioIn: HANDLE | 0n, pClassGuid: PGUID, ulInstance: ULONG, pServiceInfoIn: PBLUETOOTH_LOCAL_SERVICE_INFO): DWORD {
+    return BluetoothApis.Load('BluetoothSetLocalServiceInfo')(hRadioIn, pClassGuid, ulInstance, pServiceInfoIn);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothsetservicestate
+  public static BluetoothSetServiceState(hRadio: HANDLE, pbtdi: PBLUETOOTH_DEVICE_INFO, pGuidService: PGUID, dwServiceFlags: DWORD): DWORD {
+    return BluetoothApis.Load('BluetoothSetServiceState')(hRadio, pbtdi, pGuidService, dwServiceFlags);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothunregisterauthentication
+  public static BluetoothUnregisterAuthentication(hRegHandle: HBLUETOOTH_AUTHENTICATION_REGISTRATION): BOOL {
+    return BluetoothApis.Load('BluetoothUnregisterAuthentication')(hRegHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/bluetoothapis/nf-bluetoothapis-bluetoothupdatedevicerecord
+  public static BluetoothUpdateDeviceRecord(pbtdi: PBLUETOOTH_DEVICE_INFO): DWORD {
+    return BluetoothApis.Load('BluetoothUpdateDeviceRecord')(pbtdi);
+  }
+}
+
+export default BluetoothApis;

package/types/BluetoothApis.ts

@@ -0,0 +1,52 @@
+import type { Pointer } from 'bun:ffi';
+
+export type { BOOL, DWORD, HANDLE, HRESULT, LPBYTE, LPCWSTR, LPDWORD, LPVOID, LPWSTR, NULL, PHANDLE, PULONG, PVOID, ULONG, USHORT } from '@bun-win32/core';
+
+export const BLUETOOTH_GATT_FLAG_CONNECTION_AUTHENTICATED = 0x0000_0002;
+export const BLUETOOTH_GATT_FLAG_CONNECTION_ENCRYPTED = 0x0000_0001;
+export const BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_CACHE = 0x0000_0008;
+export const BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICE = 0x0000_0004;
+export const BLUETOOTH_GATT_FLAG_NONE = 0x0000_0000;
+export const BLUETOOTH_GATT_FLAG_RETURN_ALL = 0x0000_0040;
+export const BLUETOOTH_GATT_FLAG_SIGNED_WRITE = 0x0000_0010;
+export const BLUETOOTH_GATT_FLAG_WRITE_WITHOUT_RESPONSE = 0x0000_0020;
+export const BLUETOOTH_MAX_NAME_SIZE = 248;
+export const BLUETOOTH_MAX_PASSKEY_SIZE = 16;
+export const BLUETOOTH_MAX_SERVICE_NAME_SIZE = 256;
+export const BLUETOOTH_SERVICE_DISABLE = 0x00;
+export const BLUETOOTH_SERVICE_ENABLE = 0x01;
+
+export enum BTH_LE_GATT_EVENT_TYPE {
+  CharacteristicValueChangedEvent = 0,
+}
+
+export type BLUETOOTH_GATT_EVENT_HANDLE = bigint;
+export type BTH_LE_GATT_RELIABLE_WRITE_CONTEXT = bigint;
+export type HBLUETOOTH_AUTHENTICATION_REGISTRATION = bigint;
+export type HBLUETOOTH_DEVICE_FIND = bigint;
+export type HBLUETOOTH_RADIO_FIND = bigint;
+export type PBLUETOOTH_ADDRESS = Pointer;
+export type PBLUETOOTH_AUTHENTICATE_RESPONSE = Pointer;
+export type PBLUETOOTH_DEVICE_INFO = Pointer;
+export type PBLUETOOTH_DEVICE_SEARCH_PARAMS = Pointer;
+export type PBLUETOOTH_FIND_RADIO_PARAMS = Pointer;
+export type PBLUETOOTH_GATT_EVENT_HANDLE = Pointer;
+export type PBLUETOOTH_LOCAL_SERVICE_INFO = Pointer;
+export type PBLUETOOTH_RADIO_INFO = Pointer;
+export type PBTH_LE_GATT_CHARACTERISTIC = Pointer;
+export type PBTH_LE_GATT_CHARACTERISTIC_VALUE = Pointer;
+export type PBTH_LE_GATT_DESCRIPTOR = Pointer;
+export type PBTH_LE_GATT_DESCRIPTOR_VALUE = Pointer;
+export type PBTH_LE_GATT_RELIABLE_WRITE_CONTEXT = Pointer;
+export type PBTH_LE_GATT_SERVICE = Pointer;
+export type PFNBLUETOOTH_GATT_EVENT_CALLBACK = Pointer;
+export type PFN_AUTHENTICATION_CALLBACK = Pointer;
+export type PFN_AUTHENTICATION_CALLBACK_EX = Pointer;
+export type PFN_BLUETOOTH_ENUM_ATTRIBUTES_CALLBACK = Pointer;
+export type PGUID = Pointer;
+export type PHBLUETOOTH_AUTHENTICATION_REGISTRATION = Pointer;
+export type PHBLUETOOTH_CONTAINER_ELEMENT = Pointer;
+export type PSDP_ELEMENT_DATA = Pointer;
+export type PSDP_STRING_TYPE_DATA = Pointer;
+export type PUSHORT = Pointer;
+export type UCHAR = number;