@bun-win32/powrprof 1.0.0

package/AI.md

@@ -0,0 +1,73 @@
+# AI Guide for @bun-win32/powrprof
+
+How to use this package, not what the Win32 API does.
+
+## Usage
+
+```ts
+import PowrProf, { POWER_INFORMATION_LEVEL } from '@bun-win32/powrprof';
+
+// Methods bind lazily on first call
+const result = PowrProf.CallNtPowerInformation(level, null, 0, buf.ptr, buf.byteLength);
+
+// Preload: array, single string, or no args (all symbols)
+PowrProf.Preload(['CallNtPowerInformation', 'PowerGetActiveScheme']);
+PowrProf.Preload('SetSuspendState');
+PowrProf.Preload();
+```
+
+## Where To Look
+
+| Need                              | Read                  |
+| --------------------------------- | --------------------- |
+| Find a method or its MS Docs link | `structs/PowrProf.ts` |
+| Find types, enums, constants      | `types/PowrProf.ts`   |
+| Quick examples                    | `README.md`           |
+
+`index.ts` re-exports the class and all types — import from `@bun-win32/powrprof` directly.
+
+## Calling Convention
+
+All documented `powrprof.dll` exports are bound. Each method maps 1:1 to its DLL export. Names, parameter names, and order match Microsoft Docs.
+
+### Strings
+
+Most powrprof functions work with GUIDs and binary data rather than strings. Where strings are used (e.g. `WritePwrScheme`), they take UTF-16LE NUL-terminated buffers.
+
+```ts
+const wide = Buffer.from('My Scheme\0', 'utf16le');  // LPCWSTR
+PowrProf.WritePwrScheme(idBuf.ptr, wide.ptr, null, policyBuf.ptr);
+
+// Reading a wide string back from a buffer:
+const text = new TextDecoder('utf-16').decode(buf).replace(/\0.*$/, '');
+```
+
+### Return types
+
+- `HANDLE`, `HKEY`, `HPOWERNOTIFY` → `bigint`
+- `DWORD`, `UINT`, `BOOL`, `ULONG`, `REGSAM`, `NTSTATUS` → `number`
+- `BOOLEAN` → `number` (0 or 1, unsigned byte)
+- `HRESULT` → `number` (signed 32-bit)
+- `LPVOID`, `LPWSTR`, `LPCGUID`, `PUCHAR`, etc. → `Pointer`
+- Win32 `BOOL` is `number` (0 or non-zero), **not** JS `boolean`. Do not compare with `=== true`.
+
+### Pointers, handles, out-parameters
+
+- **Pointer** params (`LPCGUID`, `PUCHAR`, `Pointer`): pass `buffer.ptr` from a caller-allocated `Buffer`.
+- **Handle** params (`HKEY`, `HANDLE`, `HPOWERNOTIFY`): pass a `bigint` value.
+- **Out-parameters**: allocate a `Buffer`, pass `.ptr`, read the result after the call.
+
+```ts
+const out = Buffer.alloc(4);
+PowrProf.PowerReadACValueIndex(0n, schemeGuid.ptr, null, settingGuid.ptr, out.ptr);
+const value = new DataView(out.buffer).getUint32(0, true);
+```
+
+### Nullability
+
+- `| NULL` in a signature → pass `null` (optional pointer).
+- `| 0n` in a signature → pass `0n` (optional handle).
+
+## Errors and Cleanup
+
+Return values are raw. Most modern Power* functions return `DWORD` error codes (`0` = `ERROR_SUCCESS`). Legacy functions return `BOOLEAN` (`1` = success, `0` = failure). `CallNtPowerInformation` returns `NTSTATUS` (`0` = `STATUS_SUCCESS`). Resource cleanup is your responsibility — same as raw Win32.

package/README.md

@@ -0,0 +1,67 @@
+# @bun-win32/powrprof
+
+Zero-dependency, zero-overhead Win32 PowrProf bindings for [Bun](https://bun.sh) on Windows.
+
+## Overview
+
+`@bun-win32/powrprof` exposes the `powrprof.dll` exports using [Bun](https://bun.sh)'s FFI. It provides a single class, `PowrProf`, 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 `powrprof.dll` (power schemes, policies, sleep states, and battery management).
+- In-source docs in `structs/PowrProf.ts` with links to Microsoft Docs.
+- Lazy binding on first call; optional eager preload (`PowrProf.Preload()`).
+- No wrapper overhead; calls map 1:1 to native APIs.
+- Strongly-typed Win32 aliases (see `types/PowrProf.ts`).
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+- Windows 10 or later
+
+## Installation
+
+```sh
+bun add @bun-win32/powrprof
+```
+
+## Quick Start
+
+```ts
+import PowrProf, { POWER_INFORMATION_LEVEL } from '@bun-win32/powrprof';
+
+// Get system battery state
+const batteryState = Buffer.alloc(64);
+const status = PowrProf.CallNtPowerInformation(
+  POWER_INFORMATION_LEVEL.SystemBatteryState,
+  null, 0,
+  batteryState.ptr, batteryState.byteLength,
+);
+
+if (status === 0) {
+  const view = new DataView(batteryState.buffer);
+  const acOnLine = view.getUint8(0);
+  const batteryPresent = view.getUint8(1);
+  console.log(`AC: ${acOnLine ? 'plugged in' : 'battery'}`);
+  console.log(`Battery present: ${batteryPresent ? 'yes' : 'no'}`);
+}
+```
+
+> [!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
+bun run example/powrprof.ts
+```
+
+## Notes
+
+- Either rely on lazy binding or call `PowrProf.Preload()`.
+- Windows only. Bun runtime required.

package/index.ts

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

package/package.json

@@ -0,0 +1,56 @@
+{
+  "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 POWRPROF bindings for Bun (FFI) on Windows.",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "module": "index.ts",
+  "name": "@bun-win32/powrprof",
+  "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/powrprof"
+  },
+  "type": "module",
+  "version": "1.0.0",
+  "main": "./index.ts",
+  "keywords": [
+    "bun",
+    "ffi",
+    "win32",
+    "windows",
+    "powrprof",
+    "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/powrprof.ts"
+  }
+}

package/structs/PowrProf.ts

@@ -0,0 +1,616 @@
+import { type FFIFunction, FFIType } from 'bun:ffi';
+import { Win32 } from '@bun-win32/core';
+
+import type {
+  BOOL,
+  BOOLEAN,
+  DWORD,
+  EFFECTIVE_POWER_MODE_CALLBACK,
+  HANDLE,
+  HKEY,
+  HPOWERNOTIFY,
+  HRESULT,
+  LPCGUID,
+  LPCWSTR,
+  LPDWORD,
+  LPGUID,
+  LPARAM,
+  LPBYTE,
+  NULL,
+  NTSTATUS,
+  PADMINISTRATOR_POWER_POLICY,
+  PBYTE,
+  PGLOBAL_POWER_POLICY,
+  PHPOWERNOTIFY,
+  PMACHINE_PROCESSOR_POWER_POLICY,
+  POWER_DATA_ACCESSOR,
+  POWER_INFORMATION_LEVEL,
+  POWER_PLATFORM_ROLE,
+  PPOWER_POLICY,
+  PSYSTEM_POWER_CAPABILITIES,
+  PTHERMAL_EVENT,
+  PUCHAR,
+  PUINT,
+  PULONG,
+  PVOID,
+  PWRSCHEMESENUMPROC,
+  REGSAM,
+  UINT,
+  ULONG,
+} from '../types/PowrProf';
+
+/**
+ * Thin, lazy-loaded FFI bindings for `powrprof.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 PowrProf from './structs/PowrProf';
+ *
+ * // Lazy: bind on first call
+ * const result = PowrProf.GetPwrCapabilities(buffer.ptr);
+ *
+ * // Or preload a subset to avoid per-symbol lazy binding cost
+ * PowrProf.Preload(['GetPwrCapabilities', 'PowerGetActiveScheme']);
+ * ```
+ */
+class PowrProf extends Win32 {
+  protected static override name = 'powrprof.dll';
+
+  /** @inheritdoc */
+  protected static override readonly Symbols = {
+    CallNtPowerInformation: { args: [FFIType.i32, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    CanUserWritePwrScheme: { args: [], returns: FFIType.u8 },
+    DeletePwrScheme: { args: [FFIType.u32], returns: FFIType.u8 },
+    DevicePowerClose: { args: [], returns: FFIType.u8 },
+    DevicePowerEnumDevices: { args: [FFIType.u32, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    DevicePowerOpen: { args: [FFIType.u32], returns: FFIType.u8 },
+    DevicePowerSetDeviceState: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.u32 },
+    EnumPwrSchemes: { args: [FFIType.ptr, FFIType.i64], returns: FFIType.u8 },
+    GetActivePwrScheme: { args: [FFIType.ptr], returns: FFIType.u8 },
+    GetCurrentPowerPolicies: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    GetPwrCapabilities: { args: [FFIType.ptr], returns: FFIType.u8 },
+    GetPwrDiskSpindownRange: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    IsAdminOverrideActive: { args: [FFIType.ptr], returns: FFIType.u8 },
+    IsPwrHibernateAllowed: { args: [], returns: FFIType.u8 },
+    IsPwrShutdownAllowed: { args: [], returns: FFIType.u8 },
+    IsPwrSuspendAllowed: { args: [], returns: FFIType.u8 },
+    PowerCanRestoreIndividualDefaultPowerScheme: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerCreatePossibleSetting: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerCreateSetting: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerDeleteScheme: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    PowerDeterminePlatformRole: { args: [], returns: FFIType.i32 },
+    PowerDeterminePlatformRoleEx: { args: [FFIType.u32], returns: FFIType.i32 },
+    PowerDuplicateScheme: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerEnumerate: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerGetActiveScheme: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    PowerGetUserConfiguredACPowerMode: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerGetUserConfiguredDCPowerMode: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerImportPowerScheme: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerIsSettingRangeDefined: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    PowerOpenSystemPowerKey: { args: [FFIType.ptr, FFIType.u32, FFIType.i32], returns: FFIType.u32 },
+    PowerOpenUserPowerKey: { args: [FFIType.ptr, FFIType.u32, FFIType.i32], returns: FFIType.u32 },
+    PowerReadACDefaultIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadACValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadACValueIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadDCDefaultIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadDCValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadDCValueIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadDescription: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadFriendlyName: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadIconResourceSpecifier: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadPossibleDescription: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadPossibleFriendlyName: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadPossibleValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadSettingAttributes: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadValueIncrement: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadValueMax: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadValueMin: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReadValueUnitsSpecifier: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerRegisterForEffectivePowerModeNotifications: { args: [FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    PowerRegisterSuspendResumeNotification: { args: [FFIType.u32, FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    PowerRemovePowerSetting: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u32 },
+    PowerReplaceDefaultPowerSchemes: { args: [], returns: FFIType.u32 },
+    PowerReportThermalEvent: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerRestoreDefaultPowerSchemes: { args: [], returns: FFIType.u32 },
+    PowerRestoreIndividualDefaultPowerScheme: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerSetActiveScheme: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    PowerSetUserConfiguredACPowerMode: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerSetUserConfiguredDCPowerMode: { args: [FFIType.ptr], returns: FFIType.u32 },
+    PowerSettingAccessCheck: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.u32 },
+    PowerSettingAccessCheckEx: { args: [FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerSettingRegisterNotification: { args: [FFIType.ptr, FFIType.u32, FFIType.u64, FFIType.ptr], returns: FFIType.u32 },
+    PowerSettingUnregisterNotification: { args: [FFIType.u64], returns: FFIType.u32 },
+    PowerUnregisterFromEffectivePowerModeNotifications: { args: [FFIType.u64], returns: FFIType.i32 },
+    PowerUnregisterSuspendResumeNotification: { args: [FFIType.u64], returns: FFIType.u32 },
+    PowerWriteACDefaultIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteACValueIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteDCDefaultIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteDCValueIndex: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteDescription: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteFriendlyName: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteIconResourceSpecifier: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWritePossibleDescription: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWritePossibleFriendlyName: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWritePossibleValue: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteSettingAttributes: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteValueIncrement: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteValueMax: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteValueMin: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    PowerWriteValueUnitsSpecifier: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    ReadGlobalPwrPolicy: { args: [FFIType.ptr], returns: FFIType.u8 },
+    ReadProcessorPwrScheme: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.u8 },
+    ReadPwrScheme: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.u8 },
+    SetActivePwrScheme: { args: [FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    SetSuspendState: { args: [FFIType.u8, FFIType.u8, FFIType.u8], returns: FFIType.u8 },
+    ValidatePowerPolicies: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+    WriteGlobalPwrPolicy: { args: [FFIType.ptr], returns: FFIType.u8 },
+    WriteProcessorPwrScheme: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.u8 },
+    WritePwrScheme: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u8 },
+  } as const satisfies Record<string, FFIFunction>;
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powerbase/nf-powerbase-callntpowerinformation
+  public static CallNtPowerInformation(InformationLevel: POWER_INFORMATION_LEVEL, InputBuffer: PVOID | NULL, InputBufferLength: ULONG, OutputBuffer: PVOID | NULL, OutputBufferLength: ULONG): NTSTATUS {
+    return PowrProf.Load('CallNtPowerInformation')(InformationLevel, InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-canuserwritepwrscheme
+  public static CanUserWritePwrScheme(): BOOLEAN {
+    return PowrProf.Load('CanUserWritePwrScheme')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-deletepwrscheme
+  public static DeletePwrScheme(uiID: UINT): BOOLEAN {
+    return PowrProf.Load('DeletePwrScheme')(uiID);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-devicepowerclose
+  public static DevicePowerClose(): BOOLEAN {
+    return PowrProf.Load('DevicePowerClose')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-devicepowerenumdevices
+  public static DevicePowerEnumDevices(QueryIndex: ULONG, QueryInterpretationFlags: ULONG, QueryFlags: ULONG, pReturnBuffer: PBYTE | NULL, pBufferSize: PULONG): BOOLEAN {
+    return PowrProf.Load('DevicePowerEnumDevices')(QueryIndex, QueryInterpretationFlags, QueryFlags, pReturnBuffer, pBufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-devicepoweropen
+  public static DevicePowerOpen(DebugMask: ULONG): BOOLEAN {
+    return PowrProf.Load('DevicePowerOpen')(DebugMask);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-devicepowersetdevicestate
+  public static DevicePowerSetDeviceState(DeviceDescription: LPCWSTR, SetFlags: ULONG, SetData: PVOID | NULL): DWORD {
+    return PowrProf.Load('DevicePowerSetDeviceState')(DeviceDescription, SetFlags, SetData);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-enumpwrschemes
+  public static EnumPwrSchemes(lpfn: PWRSCHEMESENUMPROC, lParam: LPARAM): BOOLEAN {
+    return PowrProf.Load('EnumPwrSchemes')(lpfn, lParam);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-getactivepwrscheme
+  public static GetActivePwrScheme(puiID: PUINT): BOOLEAN {
+    return PowrProf.Load('GetActivePwrScheme')(puiID);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-getcurrentpowerpolicies
+  public static GetCurrentPowerPolicies(pGlobalPowerPolicy: PGLOBAL_POWER_POLICY, pPowerPolicy: PPOWER_POLICY): BOOLEAN {
+    return PowrProf.Load('GetCurrentPowerPolicies')(pGlobalPowerPolicy, pPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powerbase/nf-powerbase-getpwrcapabilities
+  public static GetPwrCapabilities(lpspc: PSYSTEM_POWER_CAPABILITIES): BOOLEAN {
+    return PowrProf.Load('GetPwrCapabilities')(lpspc);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-getpwrdiskspindownrange
+  public static GetPwrDiskSpindownRange(puiMax: PUINT, puiMin: PUINT): BOOLEAN {
+    return PowrProf.Load('GetPwrDiskSpindownRange')(puiMax, puiMin);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-isadminoverrideactive
+  public static IsAdminOverrideActive(papp: PADMINISTRATOR_POWER_POLICY): BOOLEAN {
+    return PowrProf.Load('IsAdminOverrideActive')(papp);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-ispwrhibernateallowed
+  public static IsPwrHibernateAllowed(): BOOLEAN {
+    return PowrProf.Load('IsPwrHibernateAllowed')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-ispwrshutdownallowed
+  public static IsPwrShutdownAllowed(): BOOLEAN {
+    return PowrProf.Load('IsPwrShutdownAllowed')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-ispwrsuspendallowed
+  public static IsPwrSuspendAllowed(): BOOLEAN {
+    return PowrProf.Load('IsPwrSuspendAllowed')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powercanrestoreindividualdefaultpowerscheme
+  public static PowerCanRestoreIndividualDefaultPowerScheme(SchemeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerCanRestoreIndividualDefaultPowerScheme')(SchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powercreatepossiblesetting
+  public static PowerCreatePossibleSetting(RootSystemPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID, PowerSettingGuid: LPCGUID, PossibleSettingIndex: ULONG): DWORD {
+    return PowrProf.Load('PowerCreatePossibleSetting')(RootSystemPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, PossibleSettingIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powercreatesetting
+  public static PowerCreateSetting(RootSystemPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID, PowerSettingGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerCreateSetting')(RootSystemPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerdeletescheme
+  public static PowerDeleteScheme(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerDeleteScheme')(RootPowerKey, SchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerdetermineplatformrole
+  public static PowerDeterminePlatformRole(): POWER_PLATFORM_ROLE {
+    return PowrProf.Load('PowerDeterminePlatformRole')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powerbase/nf-powerbase-powerdetermineplatformroleex
+  public static PowerDeterminePlatformRoleEx(Version: ULONG): POWER_PLATFORM_ROLE {
+    return PowrProf.Load('PowerDeterminePlatformRoleEx')(Version);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerduplicatescheme
+  public static PowerDuplicateScheme(RootPowerKey: HKEY | 0n, SourceSchemeGuid: LPCGUID, DestinationSchemeGuid: PVOID): DWORD {
+    return PowrProf.Load('PowerDuplicateScheme')(RootPowerKey, SourceSchemeGuid, DestinationSchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerenumerate
+  public static PowerEnumerate(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, AccessFlags: POWER_DATA_ACCESSOR, Index: ULONG, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerEnumerate')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, AccessFlags, Index, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powergetactivescheme
+  public static PowerGetActiveScheme(UserRootPowerKey: HKEY | 0n, ActivePolicyGuid: PVOID): DWORD {
+    return PowrProf.Load('PowerGetActiveScheme')(UserRootPowerKey, ActivePolicyGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powergetuserconfiguredacpowermode
+  public static PowerGetUserConfiguredACPowerMode(PowerModeGuid: LPGUID): DWORD {
+    return PowrProf.Load('PowerGetUserConfiguredACPowerMode')(PowerModeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powergetuserconfigureddcpowermode
+  public static PowerGetUserConfiguredDCPowerMode(PowerModeGuid: LPGUID): DWORD {
+    return PowrProf.Load('PowerGetUserConfiguredDCPowerMode')(PowerModeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerimportpowerscheme
+  public static PowerImportPowerScheme(RootPowerKey: HKEY | 0n, ImportFileNamePath: LPCWSTR, DestinationSchemeGuid: PVOID): DWORD {
+    return PowrProf.Load('PowerImportPowerScheme')(RootPowerKey, ImportFileNamePath, DestinationSchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerissettingrangedefined
+  public static PowerIsSettingRangeDefined(SubKeyGuid: LPCGUID | NULL, SettingGuid: LPCGUID | NULL): BOOLEAN {
+    return PowrProf.Load('PowerIsSettingRangeDefined')(SubKeyGuid, SettingGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-poweropensystempowerkey
+  public static PowerOpenSystemPowerKey(phSystemPowerKey: PVOID, Access: REGSAM, OpenExisting: BOOL): DWORD {
+    return PowrProf.Load('PowerOpenSystemPowerKey')(phSystemPowerKey, Access, OpenExisting);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-poweropenuserpowerkey
+  public static PowerOpenUserPowerKey(phUserPowerKey: PVOID, Access: REGSAM, OpenExisting: BOOL): DWORD {
+    return PowrProf.Load('PowerOpenUserPowerKey')(phUserPowerKey, Access, OpenExisting);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadacdefaultindex
+  public static PowerReadACDefaultIndex(RootPowerKey: HKEY | 0n, SchemePersonalityGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID, AcDefaultIndex: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadACDefaultIndex')(RootPowerKey, SchemePersonalityGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, AcDefaultIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerreadacvalue
+  public static PowerReadACValue(
+    RootPowerKey: HKEY | 0n,
+    SchemeGuid: LPCGUID | NULL,
+    SubGroupOfPowerSettingsGuid: LPCGUID | NULL,
+    PowerSettingGuid: LPCGUID | NULL,
+    Type: PULONG | NULL,
+    Buffer: LPBYTE | NULL,
+    BufferSize: LPDWORD | NULL,
+  ): DWORD {
+    return PowrProf.Load('PowerReadACValue')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Type, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadacvalueindex
+  public static PowerReadACValueIndex(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, AcValueIndex: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadACValueIndex')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, AcValueIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreaddcdefaultindex
+  public static PowerReadDCDefaultIndex(RootPowerKey: HKEY | 0n, SchemePersonalityGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID, DcDefaultIndex: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadDCDefaultIndex')(RootPowerKey, SchemePersonalityGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, DcDefaultIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerreaddcvalue
+  public static PowerReadDCValue(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Type: PULONG | NULL, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadDCValue')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Type, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreaddcvalueindex
+  public static PowerReadDCValueIndex(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, DcValueIndex: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadDCValueIndex')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, DcValueIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreaddescription
+  public static PowerReadDescription(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadDescription')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadfriendlyname
+  public static PowerReadFriendlyName(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadFriendlyName')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadiconresourcespecifier
+  public static PowerReadIconResourceSpecifier(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID | NULL, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadIconResourceSpecifier')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadpossibledescription
+  public static PowerReadPossibleDescription(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, PossibleSettingIndex: ULONG, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadPossibleDescription')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadpossiblefriendlyname
+  public static PowerReadPossibleFriendlyName(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, PossibleSettingIndex: ULONG, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadPossibleFriendlyName')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadpossiblevalue
+  public static PowerReadPossibleValue(
+    RootPowerKey: HKEY | 0n,
+    SubGroupOfPowerSettingsGuid: LPCGUID | NULL,
+    PowerSettingGuid: LPCGUID | NULL,
+    Type: PULONG | NULL,
+    PossibleSettingIndex: ULONG,
+    Buffer: PUCHAR | NULL,
+    BufferSize: LPDWORD,
+  ): DWORD {
+    return PowrProf.Load('PowerReadPossibleValue')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Type, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadsettingattributes
+  public static PowerReadSettingAttributes(SubGroupGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL): DWORD {
+    return PowrProf.Load('PowerReadSettingAttributes')(SubGroupGuid, PowerSettingGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadvalueincrement
+  public static PowerReadValueIncrement(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueIncrement: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadValueIncrement')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueIncrement);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadvaluemax
+  public static PowerReadValueMax(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueMaximum: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadValueMax')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueMaximum);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadvaluemin
+  public static PowerReadValueMin(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueMinimum: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadValueMin')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueMinimum);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreadvalueunitsspecifier
+  public static PowerReadValueUnitsSpecifier(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR | NULL, BufferSize: LPDWORD): DWORD {
+    return PowrProf.Load('PowerReadValueUnitsSpecifier')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerregisterforeffectivepowermodenotifications
+  public static PowerRegisterForEffectivePowerModeNotifications(Version: ULONG, Callback: EFFECTIVE_POWER_MODE_CALLBACK, Context: PVOID | NULL, RegistrationHandle: PVOID): HRESULT {
+    return PowrProf.Load('PowerRegisterForEffectivePowerModeNotifications')(Version, Callback, Context, RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powerbase/nf-powerbase-powerregistersuspendresumenotification
+  public static PowerRegisterSuspendResumeNotification(Flags: DWORD, Recipient: HANDLE, RegistrationHandle: PHPOWERNOTIFY): DWORD {
+    return PowrProf.Load('PowerRegisterSuspendResumeNotification')(Flags, Recipient, RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerremovepowersetting
+  public static PowerRemovePowerSetting(PowerSettingSubKeyGuid: LPCGUID, PowerSettingGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerRemovePowerSetting')(PowerSettingSubKeyGuid, PowerSettingGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreplacedefaultpowerschemes
+  public static PowerReplaceDefaultPowerSchemes(): DWORD {
+    return PowrProf.Load('PowerReplaceDefaultPowerSchemes')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerreportthermalevent
+  public static PowerReportThermalEvent(Event: PTHERMAL_EVENT): DWORD {
+    return PowrProf.Load('PowerReportThermalEvent')(Event);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerrestoredefaultpowerschemes
+  public static PowerRestoreDefaultPowerSchemes(): DWORD {
+    return PowrProf.Load('PowerRestoreDefaultPowerSchemes')();
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerrestoreindividualdefaultpowerscheme
+  public static PowerRestoreIndividualDefaultPowerScheme(SchemeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerRestoreIndividualDefaultPowerScheme')(SchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powersetactivescheme
+  public static PowerSetActiveScheme(UserRootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerSetActiveScheme')(UserRootPowerKey, SchemeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powersetuserconfiguredacpowermode
+  public static PowerSetUserConfiguredACPowerMode(PowerModeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerSetUserConfiguredACPowerMode')(PowerModeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powersetuserconfigureddcpowermode
+  public static PowerSetUserConfiguredDCPowerMode(PowerModeGuid: LPCGUID): DWORD {
+    return PowrProf.Load('PowerSetUserConfiguredDCPowerMode')(PowerModeGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powersettingaccesscheck
+  public static PowerSettingAccessCheck(AccessFlags: POWER_DATA_ACCESSOR, PowerGuid: LPCGUID | NULL): DWORD {
+    return PowrProf.Load('PowerSettingAccessCheck')(AccessFlags, PowerGuid);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powersettingaccesscheckex
+  public static PowerSettingAccessCheckEx(AccessFlags: POWER_DATA_ACCESSOR, PowerGuid: LPCGUID | NULL, AccessType: REGSAM): DWORD {
+    return PowrProf.Load('PowerSettingAccessCheckEx')(AccessFlags, PowerGuid, AccessType);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powersettingregisternotification
+  public static PowerSettingRegisterNotification(SettingGuid: LPCGUID, Flags: DWORD, Recipient: HANDLE, RegistrationHandle: PHPOWERNOTIFY): DWORD {
+    return PowrProf.Load('PowerSettingRegisterNotification')(SettingGuid, Flags, Recipient, RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powersettingunregisternotification
+  public static PowerSettingUnregisterNotification(RegistrationHandle: HPOWERNOTIFY): DWORD {
+    return PowrProf.Load('PowerSettingUnregisterNotification')(RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerunregisterfromeffectivepowermodenotifications
+  public static PowerUnregisterFromEffectivePowerModeNotifications(RegistrationHandle: HPOWERNOTIFY): HRESULT {
+    return PowrProf.Load('PowerUnregisterFromEffectivePowerModeNotifications')(RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powerbase/nf-powerbase-powerunregistersuspendresumenotification
+  public static PowerUnregisterSuspendResumeNotification(RegistrationHandle: HPOWERNOTIFY): DWORD {
+    return PowrProf.Load('PowerUnregisterSuspendResumeNotification')(RegistrationHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwriteacdefaultindex
+  public static PowerWriteACDefaultIndex(RootSystemPowerKey: HKEY | 0n, SchemePersonalityGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID, DefaultAcIndex: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteACDefaultIndex')(RootSystemPowerKey, SchemePersonalityGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, DefaultAcIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerwriteacvalueindex
+  public static PowerWriteACValueIndex(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, AcValueIndex: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteACValueIndex')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, AcValueIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritedcdefaultindex
+  public static PowerWriteDCDefaultIndex(RootSystemPowerKey: HKEY | 0n, SchemePersonalityGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID, DefaultDcIndex: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteDCDefaultIndex')(RootSystemPowerKey, SchemePersonalityGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, DefaultDcIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powersetting/nf-powersetting-powerwritedcvalueindex
+  public static PowerWriteDCValueIndex(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, DcValueIndex: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteDCValueIndex')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, DcValueIndex);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritedescription
+  public static PowerWriteDescription(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteDescription')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritefriendlyname
+  public static PowerWriteFriendlyName(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteFriendlyName')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwriteiconresourcespecifier
+  public static PowerWriteIconResourceSpecifier(RootPowerKey: HKEY | 0n, SchemeGuid: LPCGUID, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteIconResourceSpecifier')(RootPowerKey, SchemeGuid, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritepossibledescription
+  public static PowerWritePossibleDescription(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWritePossibleDescription')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritepossiblefriendlyname
+  public static PowerWritePossibleFriendlyName(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWritePossibleFriendlyName')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritepossiblevalue
+  public static PowerWritePossibleValue(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Type: ULONG, PossibleSettingIndex: ULONG, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWritePossibleValue')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Type, PossibleSettingIndex, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritesettingattributes
+  public static PowerWriteSettingAttributes(SubGroupGuid: LPCGUID, PowerSettingGuid: LPCGUID | NULL, Attributes: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteSettingAttributes')(SubGroupGuid, PowerSettingGuid, Attributes);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritevalueincrement
+  public static PowerWriteValueIncrement(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueIncrement: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteValueIncrement')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueIncrement);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritevaluemax
+  public static PowerWriteValueMax(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueMaximum: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteValueMax')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueMaximum);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritevaluemin
+  public static PowerWriteValueMin(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, ValueMinimum: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteValueMin')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, ValueMinimum);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-powerwritevalueunitsspecifier
+  public static PowerWriteValueUnitsSpecifier(RootPowerKey: HKEY | 0n, SubGroupOfPowerSettingsGuid: LPCGUID | NULL, PowerSettingGuid: LPCGUID | NULL, Buffer: PUCHAR, BufferSize: DWORD): DWORD {
+    return PowrProf.Load('PowerWriteValueUnitsSpecifier')(RootPowerKey, SubGroupOfPowerSettingsGuid, PowerSettingGuid, Buffer, BufferSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-readglobalpwrpolicy
+  public static ReadGlobalPwrPolicy(pGlobalPowerPolicy: PGLOBAL_POWER_POLICY): BOOLEAN {
+    return PowrProf.Load('ReadGlobalPwrPolicy')(pGlobalPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-readprocessorpwrscheme
+  public static ReadProcessorPwrScheme(uiID: UINT, pMachineProcessorPowerPolicy: PMACHINE_PROCESSOR_POWER_POLICY): BOOLEAN {
+    return PowrProf.Load('ReadProcessorPwrScheme')(uiID, pMachineProcessorPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-readpwrscheme
+  public static ReadPwrScheme(uiID: UINT, pPowerPolicy: PPOWER_POLICY): BOOLEAN {
+    return PowrProf.Load('ReadPwrScheme')(uiID, pPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-setactivepwrscheme
+  public static SetActivePwrScheme(uiID: UINT, pGlobalPowerPolicy: PGLOBAL_POWER_POLICY | NULL, pPowerPolicy: PPOWER_POLICY | NULL): BOOLEAN {
+    return PowrProf.Load('SetActivePwrScheme')(uiID, pGlobalPowerPolicy, pPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-setsuspendstate
+  public static SetSuspendState(bHibernate: BOOLEAN, bForce: BOOLEAN, bWakeupEventsDisabled: BOOLEAN): BOOLEAN {
+    return PowrProf.Load('SetSuspendState')(bHibernate, bForce, bWakeupEventsDisabled);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-validatepowerpolicies
+  public static ValidatePowerPolicies(pGlobalPowerPolicy: PGLOBAL_POWER_POLICY, pPowerPolicy: PPOWER_POLICY): BOOLEAN {
+    return PowrProf.Load('ValidatePowerPolicies')(pGlobalPowerPolicy, pPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-writeglobalpwrpolicy
+  public static WriteGlobalPwrPolicy(pGlobalPowerPolicy: PGLOBAL_POWER_POLICY): BOOLEAN {
+    return PowrProf.Load('WriteGlobalPwrPolicy')(pGlobalPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-writeprocessorpwrscheme
+  public static WriteProcessorPwrScheme(uiID: UINT, pMachineProcessorPowerPolicy: PMACHINE_PROCESSOR_POWER_POLICY): BOOLEAN {
+    return PowrProf.Load('WriteProcessorPwrScheme')(uiID, pMachineProcessorPowerPolicy);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/powrprof/nf-powrprof-writepwrscheme
+  public static WritePwrScheme(puiID: PUINT, lpszSchemeName: LPCWSTR, lpszDescription: LPCWSTR | NULL, lpScheme: PPOWER_POLICY): BOOLEAN {
+    return PowrProf.Load('WritePwrScheme')(puiID, lpszSchemeName, lpszDescription, lpScheme);
+  }
+}
+
+export default PowrProf;

package/types/PowrProf.ts

@@ -0,0 +1,112 @@
+import type { Pointer } from 'bun:ffi';
+
+export type { BOOL, BOOLEAN, DWORD, HANDLE, HRESULT, LPARAM, LPBYTE, LPCWSTR, LPDWORD, NULL, PBYTE, PULONG, PVOID, UINT, ULONG } from '@bun-win32/core';
+
+export const NO_SUBGROUP_GUID = Buffer.from([0x3e, 0x41, 0xa3, 0xfe, 0x05, 0x7e, 0x11, 0x49, 0x9a, 0x71, 0x70, 0x03, 0x31, 0xf1, 0xc2, 0x94]);
+
+export enum POWER_DATA_ACCESSOR {
+  ACCESS_AC_POWER_SETTING_INDEX = 0x00,
+  ACCESS_AC_POWER_SETTING_MAX = 0x15,
+  ACCESS_AC_POWER_SETTING_MIN = 0x17,
+  ACCESS_ACTIVE_OVERLAY_SCHEME = 0x1b,
+  ACCESS_ACTIVE_SCHEME = 0x13,
+  ACCESS_ATTRIBUTES = 0x0f,
+  ACCESS_CREATE_SCHEME = 0x14,
+  ACCESS_DC_POWER_SETTING_INDEX = 0x01,
+  ACCESS_DC_POWER_SETTING_MAX = 0x16,
+  ACCESS_DC_POWER_SETTING_MIN = 0x18,
+  ACCESS_DEFAULT_AC_POWER_SETTING = 0x07,
+  ACCESS_DEFAULT_DC_POWER_SETTING = 0x08,
+  ACCESS_DEFAULT_SECURITY_DESCRIPTOR = 0x0e,
+  ACCESS_DESCRIPTION = 0x03,
+  ACCESS_FRIENDLY_NAME = 0x02,
+  ACCESS_ICON_RESOURCE = 0x0d,
+  ACCESS_INDIVIDUAL_SETTING = 0x12,
+  ACCESS_OVERLAY_SCHEME = 0x1a,
+  ACCESS_POSSIBLE_POWER_SETTING = 0x04,
+  ACCESS_POSSIBLE_POWER_SETTING_DESCRIPTION = 0x06,
+  ACCESS_POSSIBLE_POWER_SETTING_FRIENDLY_NAME = 0x05,
+  ACCESS_POSSIBLE_VALUE_INCREMENT = 0x0b,
+  ACCESS_POSSIBLE_VALUE_MAX = 0x0a,
+  ACCESS_POSSIBLE_VALUE_MIN = 0x09,
+  ACCESS_POSSIBLE_VALUE_UNITS = 0x0c,
+  ACCESS_PROFILE = 0x19,
+  ACCESS_SCHEME = 0x10,
+  ACCESS_SUBGROUP = 0x11,
+}
+
+export enum POWER_INFORMATION_LEVEL {
+  AdministratorPowerPolicy = 0x09,
+  LastSleepTime = 0x0f,
+  LastWakeTime = 0x0e,
+  MonitorCapabilities = 0x29,
+  MonitorInvocation = 0x28,
+  NotifyUserPowerSetting = 0x1a,
+  PowerInformationLevelUnused0 = 0x1b,
+  PowerShutdownNotification = 0x27,
+  ProcessorCap = 0x22,
+  ProcessorIdleStates = 0x21,
+  ProcessorInformation = 0x0b,
+  ProcessorLoad = 0x26,
+  ProcessorPerfStates = 0x20,
+  ProcessorPowerPolicyAc = 0x12,
+  ProcessorPowerPolicyCurrent = 0x16,
+  ProcessorPowerPolicyDc = 0x13,
+  ProcessorStateHandler = 0x07,
+  ProcessorStateHandler2 = 0x0d,
+  SetPowerSettingValue = 0x19,
+  SystemBatteryState = 0x05,
+  SystemExecutionState = 0x10,
+  SystemHiberFileInformation = 0x24,
+  SystemMonitorHiberBootPowerOff = 0x1c,
+  SystemPowerCapabilities = 0x04,
+  SystemPowerInformation = 0x0c,
+  SystemPowerLoggingEntry = 0x18,
+  SystemPowerPolicyAc = 0x00,
+  SystemPowerPolicyCurrent = 0x08,
+  SystemPowerPolicyDc = 0x01,
+  SystemPowerStateHandler = 0x06,
+  SystemPowerStateLogging = 0x17,
+  SystemPowerStateNotifyHandler = 0x11,
+  SystemReserveHiberFile = 0x0a,
+  SystemVideoState = 0x1d,
+  SystemWakeSource = 0x23,
+  TraceApplicationPowerMessage = 0x1e,
+  TraceApplicationPowerMessageEnd = 0x1f,
+  TraceServicePowerMessage = 0x25,
+  VerifyProcessorPowerPolicyAc = 0x14,
+  VerifyProcessorPowerPolicyDc = 0x15,
+  VerifySystemPolicyAc = 0x02,
+  VerifySystemPolicyDc = 0x03,
+}
+
+export enum POWER_PLATFORM_ROLE {
+  PlatformRoleAppliancePC = 0x06,
+  PlatformRoleDesktop = 0x01,
+  PlatformRoleEnterpriseServer = 0x04,
+  PlatformRoleMaximum = 0x09,
+  PlatformRoleMobile = 0x02,
+  PlatformRolePerformanceServer = 0x07,
+  PlatformRoleSlate = 0x08,
+  PlatformRoleSOHOServer = 0x05,
+  PlatformRoleUnspecified = 0x00,
+  PlatformRoleWorkstation = 0x03,
+}
+
+export type EFFECTIVE_POWER_MODE_CALLBACK = Pointer;
+export type HKEY = bigint;
+export type HPOWERNOTIFY = bigint;
+export type LPCGUID = Pointer;
+export type LPGUID = Pointer;
+export type NTSTATUS = number;
+export type PADMINISTRATOR_POWER_POLICY = Pointer;
+export type PGLOBAL_POWER_POLICY = Pointer;
+export type PHPOWERNOTIFY = Pointer;
+export type PMACHINE_PROCESSOR_POWER_POLICY = Pointer;
+export type PPOWER_POLICY = Pointer;
+export type PSYSTEM_POWER_CAPABILITIES = Pointer;
+export type PTHERMAL_EVENT = Pointer;
+export type PUCHAR = Pointer;
+export type PUINT = Pointer;
+export type PWRSCHEMESENUMPROC = Pointer;
+export type REGSAM = number;