### Initializing Repository with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This command initializes the project repository, typically used for setting up development environments, installing root dependencies, or running initial build scripts as defined in the project's package.json.

```bash
npm run repo:init
```

--------------------------------

### Installing win32-api Package with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/README.zh-CN.md

This command installs the `win32-api` package from the npm registry, making it available for use in a Node.js project. It's the standard way to add the library as a runtime dependency to your application.

```sh
npm install win32-api
```

--------------------------------

### Installing win32-api with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/README.md

This command installs the `win32-api` package using npm, making it available for use in Node.js projects. It is the standard way to add the library as a dependency to your project.

```sh
npm install win32-api
```

--------------------------------

### Installing win32-api Package with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This command installs the 'win32-api' package from the npm registry into your Node.js project. It adds the library as a dependency, allowing you to import and use its Win32 API definitions.

```bash
npm install win32-api
```

--------------------------------

### Initializing Project Dependencies with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/README.zh-CN.md

This command runs the `bootstrap` script defined in the `package.json` to initialize project dependencies, typically used in monorepos managed by tools like Lerna. It prepares the project for development by installing all necessary packages across different sub-packages.

```sh
npm run bootstrap
```

--------------------------------

### Installing win32-api with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/README.md

This command installs the `win32-api` package using npm, making the Windows API FFI definitions available for use in a Node.js project. It is the primary method for integrating the library into a development environment.

```Shell
npm install win32-api
```

--------------------------------

### Installing win32-def package with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-def/README.md

This command installs the `win32-def` package, which provides essential Windows API definitions, into your Node.js project. It is a prerequisite for defining and calling native Win32 functions using the koffi FFI library.

```sh
npm install win32-def
```

--------------------------------

### Installing win32-api Package with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/README.zh-CN.md

This command installs the 'win32-api' package, making the Windows API interfaces available for use in your Node.js project.

```sh
npm install win32-api
```

--------------------------------

### Defining and Using Structures with ref-struct-di

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This example showcases an alternative approach to defining and using C-style structures with `ref-struct-di`. This library allows for dependency injection of `ref-napi`, providing more flexibility. It demonstrates creating and populating a `POINT` structure similar to `ref-struct`.

```TypeScript
// struct usage with ref-struct-di
import * as ref from 'ref-napi'
import * as StructDi from 'ref-struct-di'
import { DModel as M, DStruct as DS } from 'win32-api'

const Struct = StructDi(ref)
const point: M.POINT_Struct = new Struct(DS.POINT)()
point.x = 100
point.y = 200
console.log(point)
```

--------------------------------

### Calling Win32 API Functions Asynchronously with TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-def/README.md

This example demonstrates how to load the defined Win32 API functions and make an asynchronous call. It uses `load` from `win32-def` to get an instance of the Win32 API library and then calls `GetCursorPos_Async` to retrieve the current cursor coordinates, asserting the success of the operation.

```ts
import { load } from 'win32-def'
import { POINT_Factory } from 'win32-def/struct'

const lib = load<Win32>(options)
const { payload: pos } = POINT_Factory()

const res = await lib.GetCursorPos_Async(pos)
assert(res > 0)
console.info({ res, pos })
assert(pos.x >= 0 && pos.y >= 0)
```

--------------------------------

### Importing and Using Win32 API Functions in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/README.md

This TypeScript example demonstrates how to import specific Win32 API functions like `FindWindow` and `GetDefaultPrinter` from the `win32-api/util` module. It shows asynchronous calls to retrieve the default printer name and find a Notepad window using `FindWindowEx` after spawning the application.

```TypeScript
import {
  FindWindow, 
  GetDefaultPrinter,
} from 'win32-api/util'

// Retrieves the printer name of the default printer for the current user on the local computer
const printerName = await GetDefaultPrinter()

const child = spawn('notepad.exe')
const hWnd = await FindWindowEx(0, 0, 'Notepad', null)
```

--------------------------------

### Defining Win32 API Methods with Auto-Created Structures (TypeScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/CHANGES.v22.md

This snippet demonstrates how to define Win32 API methods using the 'win32-api' library, leveraging 'koffi' for FFI. It shows the definition of methods like ClientToScreen, EnumDisplayDevicesW, and GetCursorPos, highlighting that complex structures like LPPOINT and LPDISPLAY_DEVICEW are automatically created when the library is loaded, simplifying the FFI setup.

```TypeScript
import * as D from '##/index.def.js'
import * as S from '##/index.struct.js'
import * as T from '##/index.types.js' 

class DefWin {
  static ClientToScreen = [D.BOOL, [D.HWND, `_Inout_ ${S.LPPOINT}`]] //  S.LPPOINT == 'POINT*'
  static EnumDisplayDevicesW = [D.BOOL, [D.LPCWSTR, D.DWORD, `_Inout_ ${S.LPDISPLAY_DEVICEW}`, D.DWORD]] // S.LPDISPLAY_DEVICEW == 'DISPLAY_DEVICEW*'
  static GetCursorPos = [D.BOOL, [`_Out_ ${S.LPPOINT}`]]
}
```

--------------------------------

### Calling Win32 API Functions in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/README.md

This TypeScript example demonstrates how to import and use `win32-api` utility functions. It shows asynchronous calls to retrieve the default printer name using `GetDefaultPrinter()` and to find a window handle for an application like Notepad using `FindWindowEx()`, illustrating direct interaction with the Windows API.

```ts
import {
  FindWindow,
  GetDefaultPrinter,
} from 'win32-api/util'

// Retrieves the printer name of the default printer for the current user on the local computer
const printerName = await GetDefaultPrinter()

const child = spawn('notepad.exe')
const hWnd = await FindWindowEx(0, 0, 'Notepad', null)
```

--------------------------------

### Calling Win32 API with ref-napi and win32-api

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This example illustrates how to load a Windows DLL (kernel32.dll) using `win32-api`, allocate memory for a pointer using `ref.alloc` with predefined Windows data types, and then call a native Win32 API function (`GetModuleHandleExW`) to retrieve a module handle. It also shows how to read the returned handle value from the buffer.

```TypeScript
import * as ref from 'ref-napi'
import { K, DTypes as W } from 'win32-api'


const knl32 = K.load()

const lpszClass = Buffer.from('guard64\0', 'ucs2')
const hInstanceBuffer = ref.alloc(W.HANDLE_PVOID)
const hInstanceAddr = ref.address(hInstanceBuffer)

knl32.GetModuleHandleExW(0, lpszClass, hInstanceAddr)
// <Buffer@0x00000094D3968EC0 00 00 a4 60 ff 7f 00 00, type: { indirection: 2, name: 'uint64*' }>
console.log(hInstanceBuffer)
console.log(hInstanceBuffer.readInt32LE(0))     // -> 1621360640           (60A40000)
console.log(hInstanceBuffer.readBigUInt64LE())  // -> 140734814748672n (7FFF60A40000)
```

--------------------------------

### Using win32-api for Windows API Calls in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/README.zh-CN.md

This TypeScript snippet demonstrates how to import specific Windows API functions like FindWindow, GetDefaultPrinter, and FindWindowEx from 'win32-api/util'. It shows examples of retrieving the default printer name and finding a Notepad window by its class name.

```ts
import {
  FindWindow, 
  GetDefaultPrinter,
} from 'win32-api/util'

// 获取当前电脑当前用户默认打印机名
const printerName = await GetDefaultPrinter()

const child = spawn('notepad.exe')
const hWnd = await FindWindowEx(0, 0, 'Notepad', null)
```

--------------------------------

### Finding and Setting Window Title with Win32 API in Node.js

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This Node.js (TypeScript) example demonstrates how to use the 'win32-api' library to interact with Windows native functions. It first loads the Kernel32 and User32 DLL APIs, then finds a running Calculator window by its title using 'FindWindowExW', and subsequently changes its title using 'SetWindowTextW'. This requires a calculator program to be running manually beforehand.

```typescript
// **Find calc's hWnd, need running a calculator program manually at first**

/**
 * exposed modules:
 * C, Comctl32 for Comctl32 from lib/comctl32/api
 * K, Kernel32 for kernel32 from lib/kernel32/api
 * U, User32 for user32 from lib/user32/api
 */
import { K, U } from 'win32-api'
import * as ref from 'ref-napi'

const knl32 = K.load()
const user32 = U.load()  // load all apis defined in lib/{dll}/api from user32.dll
// const user32 = U.load(['FindWindowExW'])  // load only one api defined in lib/{dll}/api from user32.dll

const title = 'Calculator\0'    // null-terminated string
// const title = '计算器\0'    // null-terminated string 字符串必须以\0即null结尾!

const lpszWindow = Buffer.from(title, 'ucs2')
const hWnd = user32.FindWindowExW(0, 0, null, lpszWindow)

if (typeof hWnd === 'number' && hWnd > 0
  || typeof hWnd === 'bigint' && hWnd > 0
  || typeof hWnd === 'string' && hWnd.length > 0
) {
  console.log('buf: ', hWnd)

  // Change title of the Calculator
  const res = user32.SetWindowTextW(hWnd, Buffer.from('Node-Calculator\0', 'ucs2'))

  if ( ! res) {
    console.log('SetWindowTextW failed')
  }
  else {
    console.log('window title changed')
  }
}
```

--------------------------------

### Asynchronously Find and Set Window Title in Node.js

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This snippet demonstrates how to asynchronously find a running calculator window by its class name ('CalcFrame') and then change its title to 'Node-Calculator' using the 'win32-api' library. It verifies the title change by retrieving the new title. This example requires a calculator program to be running manually before execution.

```typescript
// **Find calc's hWnd, need running a calculator program manually at first**

import { U } from 'win32-api'
import * as ref from 'ref-napi'


const u32 = U.load(['FindWindowExW', 'SetWindowTextW'])
const lpszClass = Buffer.from('CalcFrame\0', 'ucs2')

u32.FindWindowExW.async(0, 0, lpszClass, null, (err, hWnd) => {
  if (err) {
    throw err
  }

  if (typeof hWnd === 'number' && hWnd > 0
    || typeof hWnd === 'bigint' && hWnd > 0
    || typeof hWnd === 'string' && hWnd.length > 0
  ) {
    const title = 'Node-Calculator'
    // Change title of the Calculator
    u32.SetWindowTextW.async(hWnd, Buffer.from(title + '\0', 'ucs2'), err2 => {
      if (err2) {
        throw err2
      }

      const buf = Buffer.alloc(title.length * 2)
      u32.GetWindowTextW.async(hWnd, buf, buf.byteLength, err3 => {
        if (err3) {
          throw err3
        }

        const str = buf.toString('ucs2').replace(/\0+$/, '')
        if (str !== title) {
          throw new Error(`title should be changed to ${title}, bug got ${str}`)
        }
      })
    })
  }
  else {
    throw new Error('FindWindowExW() failed')
  }
})
```

--------------------------------

### Defining Winspool API Methods with Multiple Choice Parameters (TypeScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/CHANGES.v22.md

This example illustrates the implementation of multiple choice parameters for a single API argument, specifically for the 'GetPrinterW' method. It shows how to define an array of possible structure types for an output parameter, requiring the 'as const' assertion. The snippet also demonstrates the corresponding synchronous and asynchronous type declarations for the method, emphasizing the need for a dedicated mapper function to handle the multiple choices at runtime.

```TypeScript
import * as D from 'win32-def/def'
import * as S from 'win32-def/struct'
import * as T from 'win32-def/types'

export class DefWinspool implements T.LibDefBase {

  static GetPrinterW = [D.BOOL, [
    D.HANDLE,
    D.DWORD,
    // multiple choice instead of `_Out_ ${D.LPBYTE}`,
    [
      `_Out_ ${S.PPRINTER_INFO_1}`,
      `_Out_ ${S.PPRINTER_INFO_4}`,
      `_Out_ ${S.PPRINTER_INFO_5}`,
      `_Out_ ${S.PPRINTER_INFO_6}`,
      `_Out_ ${S.PPRINTER_INFO_8}`,
      `_Out_ ${S.PPRINTER_INFO_9}`,
    ],
    D.DWORD,
    `_Out_ ${D.LPDWORD}`,
  ]] as const // `as const` is required for multipleChoice

}

export class Winspool implements T.LibDef2Type<typeof DefWinspool> {

  GetPrinterW: <Level extends S.PRINTER_INFO_LEVEL> (
    hPrinter: T.HANDLE,
    Level: T.DWORD,
    pPrinter: S.PRINTER_INFO_X_Type<Level>, // multiple choice
    cbBuf: T.DWORD,
    pcbNeeded: T.LPDWORD,
  ) => T.BOOL


  // You should declare async one only for generics
  GetPrinterW_Async: <Level extends S.PRINTER_INFO_LEVEL> (
    hPrinter: T.HANDLE,
    Level: T.DWORD,
    pPrinter: S.PRINTER_INFO_X_Type<Level>, // multiple choice
    cbBuf: T.DWORD,
    pcbNeeded: T.LPDWORD,
  ) => Promise<T.BOOL>
  
}
```

--------------------------------

### Initializing Project Dependencies with npm

Source: https://github.com/waitingsong/node-win32-api/blob/main/README.zh-CN.md

This command is used to set up the project's dependencies, typically in a monorepo structure managed by Lerna, ensuring all packages are linked and ready for development.

```sh
npm run bootstrap
```

--------------------------------

### Dynamically Loading Search Script for Local Access

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/globals.html

This JavaScript snippet checks if the documentation is being accessed via the 'file:' protocol. If so, it dynamically writes a script tag to load 'search.js', enabling search functionality when browsing the documentation locally.

```JavaScript
if (location.protocol == 'file:') document.write('<script src="assets/js/search.js"><' + '/script>');
```

--------------------------------

### Defining and Using Structures with ref-struct

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This snippet demonstrates how to define and instantiate a C-style structure, specifically the Windows `POINT` structure, using the `ref-struct` library. It shows how to create an instance of the structure and assign values to its `x` and `y` members, then log the structure object.

```TypeScript
// struct usage with ref-struct
import * as Struct from 'ref-struct'
import { DModel as M, DStruct as DS } from 'win32-api'

// https://msdn.microsoft.com/en-us/library/windows/desktop/dd162805(v=vs.85).aspx
const point: M.POINT_Struct = new Struct(DS.POINT)()
point.x = 100
point.y = 200
console.log(point)
```

--------------------------------

### Importing win32-api Promise APIs (TypeScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/migrate13.md

Shows how to import specific API namespaces (Comctl32, Kernel32, Ntdll, User32) from the `win32-api/promise` entry point. This allows access to the promised versions of the Win32 API functions, leveraging `pkg.exports` for modular access.

```TypeScript
import { Comctl32 } from 'win32-api/promise'
import { Kernel32 } from 'win32-api/promise'
import { Ntdll } from 'win32-api/promise'
import { User32 } from 'win32-api/promise'
```

--------------------------------

### Working with Complex Structures using ref-struct-napi and win32-api

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This snippet illustrates how to define and initialize a more complex Windows structure, `DISPLAY_DEVICEW`, using `ref-struct-napi` and the extended data structures provided by `win32-api`. It demonstrates setting the `cb` member (size in bytes) of the structure, which is often required for Windows API calls.

```TypeScript
// struct usage with ref-struct
import * as Struct from 'ref-struct-napi'
import {
  DModel as M,
  DStructExt,
} from 'win32-api'


// https://docs.microsoft.com/zh-cn/windows/win32/api/wingdi/ns-wingdi-display_devicew 
const dd: M.DISPLAY_DEVICEW_Struct = new Struct(DStructExt.DISPLAY_DEVICEW)()
dd.cb = dd.ref().byteLength
console.log(dd)
/**
Detail in:
https://github.com/waitingsong/node-win32-api/blob/master/packages/win32-api/src/data-struct-ext/wingdi.h.ts
https://github.com/waitingsong/node-win32-api/blob/master/packages/win32-api/test/user32/60_EnumDisplayDevicesW.test.ts
*/
```

--------------------------------

### Defining Win32 API Functions with TypeScript FFI

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-def/README.md

This TypeScript snippet demonstrates how to define Windows API function signatures and their corresponding types using `win32-def`. It imports necessary definitions and structures, then maps native C function parameters and return types to TypeScript for use with an FFI library like koffi.

```ts
import * as D from 'win32-def/def'
import * as S from 'win32-def/struct'
import * as T from 'win32-def/types'

export class DefWin32 extends Def_B implements T.LibDefBase {
  [x: string]: T.FnDefFullParams
  static ClientToScreen = [D.BOOL, [D.HWND, `_Inout_ ${S.LPPOINT}`]]
  static EnumDisplayDevicesW = [D.BOOL, [D.LPCWSTR, D.DWORD, `_Inout_ ${S.LPDISPLAY_DEVICEW}`, D.DWORD]]
  static FindWindowExW = [D.HWND, [D.HWND, D.HWND, D.LPCTSTR, D.LPCTSTR]]
  static GetCursorPos = [D.BOOL, [`_Out_ ${S.LPPOINT}`]]
}

export class Win32 implements T.LibDef2Type<typeof DefWin32> {
  ClientToScreen: (hWnd: T.HWND, lpPoint: S.POINT_Type) => T.BOOL

  EnumDisplayDevicesW: (
    lpDevice: T.LPCWSTR | null,
    iDevNum: T.DWORD,
    lpDisplayDevice: S.DISPLAY_DEVICEW_Type,
    dwFlags: T.DWORD,
  ) => T.BOOL

  FindWindowExW: (
    hwndParent: T.HWND,
    hwndChildAfter: T.HWND,
    lpszClass: T.LPCTSTR | null,
    lpszWindow: T.LPCTSTR | null,
  ) => T.HWND

  GetCursorPos: (lpPoint: S.POINT_Type) => T.BOOL
}
```

--------------------------------

### Migrating win32-def Imports - Current (TypeScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/migrate13.md

Demonstrates the new import syntax for `win32-def` after the v13 migration. This approach uses namespace imports (`* as`) and specifies sub-paths for common definitions (`common.def`), struct definitions (`struct.def`), and union definitions (`union.def`). This change aligns with `pkg.exports` usage.

```TypeScript
import * as M from 'win32-def'
import * as W from 'win32-def/common.def' 
import * as DS from 'win32-def/struct.def'
import * as DU from 'win32-def/union.def'
```

--------------------------------

### Migrating win32-def Imports - Before (TypeScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/migrate13.md

Illustrates the old import syntax for `win32-def` before the v13 migration. This syntax used named imports for specific modules like `DModel`, `DTypes`, `DStruct`, and `DUnion` from the main package entry point.

```TypeScript
import { DModel as M } from 'win32-def'
import { DTypes as W } from 'win32-def'
import { DStruct as DS} from 'win32-def'
import { DUnion} from 'win32-def'
```

--------------------------------

### Using Win32 API Functions in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/README.zh-CN.md

This snippet demonstrates how to import and utilize specific Win32 API functions, such as `FindWindow` and `GetDefaultPrinter`, from the `win32-api/util` module in a TypeScript application. It illustrates retrieving the default printer name and finding a window handle for a spawned process, showcasing basic interaction with Windows system functionalities. Note that `spawn` is typically from Node.js's `child_process` module.

```ts
import {
  FindWindow,
  GetDefaultPrinter,
} from 'win32-api/util'

// 获取当前电脑当前用户默认打印机名
const printerName = await GetDefaultPrinter()

const child = spawn('notepad.exe')
const hWnd = await FindWindowEx(0, 0, 'Notepad', null)
```

--------------------------------

### Importing Modules from win32-def (Current)

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/migrate13.md

This snippet demonstrates the current method for importing modules from the 'win32-def' package in version 13 and later. It uses namespace imports and specific sub-paths like 'common.def', 'struct.def', and 'union.def' due to the adoption of `pkg.exports`.

```TypeScript
import * as M from 'win32-def'
import * as W from 'win32-def/common.def' 
import * as DS from 'win32-def/struct.def'
import * as DU from 'win32-def/union.def'
```

--------------------------------

### Dynamically Loading Search Script in File Protocol (JavaScript)

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/modules/_model_.html

This JavaScript snippet dynamically injects a search script into the HTML document. It checks if the page is accessed using the 'file:' protocol, which is common for local development or offline viewing, and then loads the 'search.js' script to enable search functionality.

```JavaScript
if (location.protocol == 'file:') document.write('<script src="../assets/js/search.js"><' + '/script>');
```

--------------------------------

### Importing Promised Win32 API Namespaces

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/migrate13.md

This snippet illustrates how to import promised versions of Win32 API namespaces (e.g., Comctl32, Kernel32, Ntdll, User32) from the 'win32-api/promise' entry point. This allows for asynchronous API calls, leveraging `pkg.exports` for module resolution.

```TypeScript
import { Comctl32 } from 'win32-api/promise'
import { Kernel32 } from 'win32-api/promise'
import { Ntdll } from 'win32-api/promise'
import { User32 } from 'win32-api/promise'
```

--------------------------------

### Working with Buffers and Pointers using ref-napi

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/index.html

This snippet demonstrates the fundamental usage of `ref-napi` to treat a Node.js Buffer as a pointer. It shows how to write an integer value to a buffer, retrieve its hexadecimal memory address, assign a type to the buffer, and then dereference it to obtain the original meaningful value.

```TypeScript
import { U } from 'win32-api'
import * as ref from 'ref-napi'

// so we can all agree that a buffer with the int value written
// to it could be represented as an "int *"
const buf  = Buffer.alloc(4)
buf.writeInt32LE(12345, 0)

const hex = ref.hexAddress(buf)
console.log(typeof hex)
console.log(hex)  // ← '7FA89D006FD8'

buf.type = ref.types.int  // @ts-ignore

// now we can dereference to get the "meaningful" value
console.log(ref.deref(buf))  // ← 12345
```

--------------------------------

### Importing Modules from win32-def (Legacy)

Source: https://github.com/waitingsong/node-win32-api/blob/main/packages/win32-api/migrate13.md

This snippet shows the deprecated way of importing specific modules like DModel, DTypes, DStruct, and DUnion from the 'win32-def' package before version 13. These imports used named exports from the main package entry point.

```TypeScript
import { DModel as M } from 'win32-def'
import { DTypes as W } from 'win32-def'
import { DStruct as DS} from 'win32-def'
import { DUnion} from 'win32-def'
```

--------------------------------

### Conditionally Loading Search Script in JavaScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/enums/_model_.dllnames.html

This JavaScript snippet conditionally loads the `search.js` script into the document if the current page is accessed via the `file:` protocol. This mechanism is typically employed in locally hosted documentation to enable search functionality, as direct file access might restrict certain browser features.

```JavaScript
if (location.protocol == 'file:') document.write('<script src="../assets/js/search.js"><' + '/script>');
```

--------------------------------

### Defining kernel32 DllNames Enum Member in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/enums/_model_.dllnames.html

Defines the `kernel32` member of the `DllNames` enumeration, representing the Windows Kernel Library DLL. This string value is used to reference the `kernel32.dll` for core system functions, providing a standardized way to access this critical library.

```TypeScript
kernel32: = "kernel32"
```

--------------------------------

### Defining user32 DllNames Enum Member in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/enums/_model_.dllnames.html

Defines the `user32` member of the `DllNames` enumeration, representing the Windows User Interface Library DLL. This string value is used to reference the `user32.dll` for UI-related functions, facilitating consistent access to graphical user interface elements.

```TypeScript
user32: = "user32"
```

--------------------------------

### Defining ntdll DllNames Enum Member in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/enums/_model_.dllnames.html

Defines the `ntdll` member of the `DllNames` enumeration, representing the NT Layer DLL. This string value is used to reference the `ntdll.dll` for low-level system services, ensuring proper interaction with the Windows NT kernel.

```TypeScript
ntdll: = "ntdll"
```

--------------------------------

### Defining comctl32 DllNames Enum Member in TypeScript

Source: https://github.com/waitingsong/node-win32-api/blob/main/docs/enums/_model_.dllnames.html

Defines the `comctl32` member of the `DllNames` enumeration, representing the Common Controls Library DLL. This string value is used to reference the `comctl32.dll` in Win32 API calls, ensuring consistent naming across the application.

```TypeScript
comctl32: = "comctl32"
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.